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

Diff for /rpl/src/rpl.h between versions 1.214 and 1.258

version 1.214, 2013/03/21 14:13:55 version 1.258, 2015/01/27 14:18:09
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2013 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 56 Line 56
 #   define sched_yield(arg)  #   define sched_yield(arg)
 #endif  #endif
   
   #ifdef CYGWIN
   #   define SA_ONSTACK   0
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 73 Line 77
 #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 154 Line 159
 #   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 224 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 262 Line 266
   
 /*  /*
 ================================================================================  ================================================================================
   Bugs spécifiques    Bugs spécifiques
 ================================================================================  ================================================================================
 */  */
   
 // Néant  // Néant
   
 /*  /*
 ================================================================================  ================================================================================
Line 288  enum signaux_rpl Line 292  enum signaux_rpl
     rpl_signull = 0,      rpl_signull = 0,
     rpl_sigint,      rpl_sigint,
     rpl_sigterm,      rpl_sigterm,
     rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.      rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
     rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par      rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                         // SUSPEND                          // SUSPEND
     rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou      rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                         // FUSE. (FSTOP)                          // FUSE. (FSTOP)
     rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper      rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                         // avec FABORT)                          // avec FABORT)
     rpl_sigurg,         // Signal d'arrêt urgent      rpl_sigurg,         // Signal d'arrêt urgent
     rpl_siginject,      // Signal indiquant la présence d'une donnée à lire      rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                         // envoyée depuis le père                          // envoyée depuis le père
     rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils      rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
     rpl_sighup,      rpl_sighup,
     rpl_sigtstp,      rpl_sigtstp,
     rpl_sigexcept,      rpl_sigexcept,
Line 307  enum signaux_rpl Line 311  enum signaux_rpl
   
 #define LONGUEUR_QUEUE_SIGNAUX          1024  #define LONGUEUR_QUEUE_SIGNAUX          1024
   
 // Une structure s_queue_signaux est créée par processus (et non par thread).  // Une structure s_queue_signaux est créée par processus (et non par thread).
 // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit  // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit
 // accessible à la fois du père et des fils.  // accessible à la fois du père et des fils.
   
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct queue_signaux  typedef struct queue_signaux
 {  {
 #   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;
   
     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 368  union semun Line 365  union semun
 #   define SIGSTKSZ         65536  #   define SIGSTKSZ         65536
 #endif  #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_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 396  union semun Line 437  union semun
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
 // Signaux utilisés par défaut :  // Signaux utilisés par défaut :
 //  SIGINT  //  SIGINT
 //  SIGTSTP  //  SIGTSTP
 //  SIGCONT  //  SIGCONT
 //  SIGPIPE  //  SIGPIPE
 //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.  //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
 //  SIGHUP  //  SIGHUP
 //  SIGALRM  //  SIGALRM
   
Line 413  union semun Line 454  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   Granularité temporelle    Granularité temporelle
 ================================================================================  ================================================================================
 */  */
   
Line 455  union semun Line 496  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 473  union semun Line 511  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  
                                             __STATIC_MUTEX_INITIALIZATION__;  
     __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee      __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_sections_critiques;      __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
     __EXTERN__ pthread_mutex_t      mutex_liste_variables_partagees;      __EXTERN__ pthread_mutex_t      mutex_liste_variables_partagees;
       __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;  
   
     __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 525  sem_t *sem_open2(pid_t pid, int ordre); Line 557  sem_t *sem_open2(pid_t pid, int ordre);
 ================================================================================  ================================================================================
 */  */
   
 // Par défaut, tout est redirigé vers stderr sauf indication explicite de  // Par défaut, tout est redirigé vers stderr sauf indication explicite de
 // stdout.  // stdout.
   
 #define printf(...) transliterated_fprintf(s_etat_processus, \  #define printf(...) transliterated_fprintf(s_etat_processus, \
             stderr, __VA_ARGS__)              stderr, __VA_ARGS__)
 #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \  #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
 #define uprintf(...) transliterated_fprintf(NULL, \  #define uprintf(...) std_fprintf(stderr, __VA_ARGS__)
             stderr, __VA_ARGS__)  #define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__)
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  
             flux, __VA_ARGS__)  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
Line 557  sem_t *sem_open2(pid_t pid, int ordre); Line 587  sem_t *sem_open2(pid_t pid, int ordre);
 #   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 577  sem_t *sem_open2(pid_t pid, int ordre); Line 607  sem_t *sem_open2(pid_t pid, int ordre);
         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 617  sem_t *sem_open2(pid_t pid, int ordre); Line 647  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 691  pid_t debug_fork(); Line 721  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 759  pid_t debug_fork(); Line 772  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Paramètres du système    Paramètres du système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 778  pid_t debug_fork(); Line 791  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs système    Erreurs système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 804  pid_t debug_fork(); Line 817  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 870  pid_t debug_fork(); Line 883  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 1026  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1039  enum t_type  { ADR = 0, ALG, BIN, CHN, C
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 64 bits signés.      ADR : adresse sur 64 bits signés.
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
             La liste chaînée contient la définition convertie en notation              La liste chaînée contient la définition convertie en notation
             polonaise inversée. Ce type diffère du type 'RPN' au niveau              polonaise inversée. Ce type diffère du type 'RPN' au niveau
             du format de sortie (notation algébrique).              du format de sortie (notation algébrique).
   
     BIN : entier binaire sur 64 bits (unsigned integer8 *)      BIN : entier binaire sur 64 bits (unsigned integer8 *)
             Sans objet.              Sans objet.
             Type C/Fortran : unsigned integer8              Type C/Fortran : unsigned integer8
   
     CHN : chaine de caracteres (character*(*), unsigned char *)      CHN : chaine de caracteres (unsigned char *)
             Sans objet.              Sans objet.
   
     CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)      CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
Line 1047  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1060  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 1056  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1069  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 1083  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1096  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 1163  typedef struct rpl_mutex Line 1176  typedef struct rpl_mutex
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure sémaphore    Structure sémaphore
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1195  typedef struct marque Line 1208  typedef struct marque
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure bibliothèque    Structure bibliothèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1320  typedef struct socket Line 1333  typedef struct socket
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure liste chaînee    Structure liste chaînee
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1345  typedef struct gestion_signaux Line 1358  typedef struct gestion_signaux
     unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];      unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];
   
     /*      /*
      * 'I' : signal ignoré       * 'I' : signal ignoré
      * 'Q' : signal mis en queue pour un traitement ultérieur       * 'Q' : signal mis en queue pour un traitement ultérieur
      * 'N' : traitement normal du signal       * 'N' : traitement normal du signal
      */       */
   
Line 1394  typedef struct liste_profilage2 Line 1407  typedef struct liste_profilage2
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure contenant les fichiers graphiques (liste chaînée)    Structure contenant les fichiers graphiques (liste chaînée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1426  typedef struct nom Line 1439  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 1460  typedef struct descripteur_thread Line 1473  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 1506  typedef struct liste_pile_systeme Line 1521  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 1515  typedef struct liste_pile_systeme Line 1530  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 1527  typedef struct liste_pile_systeme Line 1542  typedef struct liste_pile_systeme
     unsigned char               type_cloture;      unsigned char               type_cloture;
   
     /*      /*
     type clôture :      type clôture :
     C     SELECT   : END termine un test SELECT/DEFAULT/END.      C     SELECT   : END termine un test SELECT/DEFAULT/END.
     D     DO       : END termine une boucle DO/UNTIL/END.      D     DO       : END termine une boucle DO/UNTIL/END.
     I     IF       : END termine un test IF/THEN (ELSE)/END.      I     IF       : END termine un test IF/THEN (ELSE)/END.
Line 1538  typedef struct liste_pile_systeme Line 1553  typedef struct liste_pile_systeme
   
     F     FOR     : NEXT ou STEP termine une boucle avec compteur.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
     S     START   : NEXT ou STEP termine une boucle sans compteur.      S     START   : NEXT ou STEP termine une boucle sans compteur.
     L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.      L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
             Elle correspond à une boucle FOR ou START mais sans son              Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
     A     FORALL  : NEXT termine une boucle sur un objet.      A     FORALL  : NEXT termine une boucle sur un objet.
     */      */
Line 1583  typedef struct variable Line 1598  typedef struct variable
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure variable partagée    Structure variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1618  typedef struct variable_statique Line 1633  typedef struct variable_statique
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine;
   
     // Position de création de la variable statique dans le programme ou dans      // Position de création de la variable statique dans le programme ou dans
     // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.      // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
   
     integer8                niveau;      integer8                niveau;
Line 1685  typedef struct tableau Line 1700  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 1726  typedef struct rpl_arguments Line 1741  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 1751  typedef struct rpl_arguments Line 1766  typedef struct rpl_arguments
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure d'arbre des instructions intrinsèques    Structure d'arbre des instructions intrinsèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1773  typedef struct instruction Line 1788  typedef struct instruction
 typedef struct arbre_variables  typedef struct arbre_variables
 {  {
     unsigned int                        noeuds_utilises;      unsigned int                        noeuds_utilises;
                                         // Nombre de noeuds utilisés dans le                                          // Nombre de noeuds utilisés dans le
                                         // tableau **noeuds                                          // tableau **noeuds
     signed int                          indice_tableau_pere;      signed int                          indice_tableau_pere;
                                         // Position de la structure dans le                                          // Position de la structure dans le
                                         // tableau **noeuds du père                                          // tableau **noeuds du père
   
     struct arbre_variables              *noeud_pere;      struct arbre_variables              *noeud_pere;
     struct arbre_variables              **noeuds;      struct arbre_variables              **noeuds;
Line 1789  typedef struct arbre_variables Line 1804  typedef struct arbre_variables
 typedef struct arbre_variables_partagees  typedef struct arbre_variables_partagees
 {  {
     unsigned int                        noeuds_utilises;      unsigned int                        noeuds_utilises;
                                         // Nombre de noeuds utilisés dans le                                          // Nombre de noeuds utilisés dans le
                                         // tableau **noeuds                                          // tableau **noeuds
     signed int                          indice_tableau_pere;      signed int                          indice_tableau_pere;
                                         // Position de la structure dans le                                          // Position de la structure dans le
                                         // tableau **noeuds du père                                          // tableau **noeuds du père
   
     struct arbre_variables_partagees    *noeud_pere;      struct arbre_variables_partagees    *noeud_pere;
     struct arbre_variables_partagees    **noeuds;      struct arbre_variables_partagees    **noeuds;
Line 1807  typedef struct arbre_variables_partagees Line 1822  typedef struct arbre_variables_partagees
     do { \      do { \
         pthread_mutexattr_t     attributs_mutex; \          pthread_mutexattr_t     attributs_mutex; \
         pthread_mutexattr_init(&attributs_mutex); \          pthread_mutexattr_init(&attributs_mutex); \
         pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); \          pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); \
         pthread_mutex_init(&(mutex), &attributs_mutex); \          pthread_mutex_init(&(mutex), &attributs_mutex); \
         pthread_mutexattr_destroy(&attributs_mutex); \          pthread_mutexattr_destroy(&attributs_mutex); \
     } while(0)      } while(0)
Line 1816  typedef struct tableau_variables Line 1831  typedef struct tableau_variables
 {  {
     unsigned char           origine;      unsigned char           origine;
     unsigned char           *nom;       // pointeur sur la struct_variable      unsigned char           *nom;       // pointeur sur la struct_variable
                                         // réelle et non copie de la chaîne                                          // réelle et non copie de la chaîne
     integer8                niveau;      integer8                niveau;
   
     struct_objet            *objet;     // pointeur sur l'objet et non copie      struct_objet            *objet;     // pointeur sur l'objet et non copie
Line 1824  typedef struct tableau_variables Line 1839  typedef struct tableau_variables
   
     logical1                variable_verrouillee;      logical1                variable_verrouillee;
     logical1                variable_masquee;      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.  // La liste des variables est une liste doublement chaînée et circulaire.
 typedef struct liste_variables  typedef struct liste_variables
 {  {
     union      union
     {      {
         // Utilisation dans la gestion des variables          // Utilisation dans la gestion des variables
         struct_variable                 *variable;          struct_variable                 *variable;
         // Utilisation dans la pile système (variables par niveau)          // Utilisation dans la pile système (variables par niveau)
         struct_liste_chainee            *liste;          struct_liste_chainee            *liste;
     };      };
   
Line 1845  typedef struct liste_variables Line 1861  typedef struct liste_variables
     struct liste_variables              *precedent;      struct liste_variables              *precedent;
 } struct_liste_variables;  } struct_liste_variables;
   
 // La liste des variables statiques et une liste double chaînée et non  // La liste des variables statiques et une liste double chaînée et non
 // circulaire.  // circulaire.
 typedef struct liste_variables_statiques  typedef struct liste_variables_statiques
 {  {
Line 1868  typedef struct liste_variables_partagees Line 1884  typedef struct liste_variables_partagees
 } struct_liste_variables_partagees;  } 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 1944  typedef struct processus Line 1996  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 1971  typedef struct processus Line 2022  typedef struct processus
   
 /* Variables                                            */  /* Variables                                            */
   
     // La liste des variables par niveau est doublement chaînée.      // La liste des variables par niveau est doublement chaînée.
     // À tout moment, elle pointe sur le niveau le plus haut existant et      // À tout moment, elle pointe sur le niveau le plus haut existant et
     // l_liste_variable_par_niveau->precedent renvoie la liste des      // l_liste_variable_par_niveau->precedent renvoie la liste des
     // définitions. l_liste_variable_par_niveau->precedent->precedent pointe      // définitions. l_liste_variable_par_niveau->precedent->precedent pointe
     // sur la liste des variables globales.      // sur la liste des variables globales.
     //      //
     // À l'initialisation :      // À l'initialisation :
     // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
     // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
   
Line 2016  typedef struct processus Line 2067  typedef struct processus
   
     struct_liste_chainee        *s_sockets;      struct_liste_chainee        *s_sockets;
   
 /*  Connecteurs aux bases de données                    */  /*  Connecteurs aux bases de données                   */
   
     struct_liste_chainee        *s_connecteurs_sql;      struct_liste_chainee        *s_connecteurs_sql;
   
 /* Bibliothèques dynamiques                             */  /* Bibliothèques dynamiques                                */
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
Line 2181  typedef struct processus Line 2232  typedef struct processus
 /* Traitement des erreurs                               */  /* Traitement des erreurs                               */
   
     int                         erreur_compilation;      int                         erreur_compilation;
     int                         erreur_execution;      volatile int                erreur_execution;
     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;
Line 2222  typedef struct processus Line 2273  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 2245  typedef struct processus Line 2296  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 2272  typedef struct processus Line 2323  typedef struct processus
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
   
     /*      /*
      * Il s'agit du nombre d'arguments utilisé pour l'évaluation       * Il s'agit du nombre d'arguments utilisé pour l'évaluation
      * des expressions algébriques.       * des expressions algébriques.
      * -1 : la fonction ne peut être dans un objet de type ALG.       * -1 : la fonction ne peut être dans un objet de type ALG.
      * -2 : nombre d'arguments inconnu       * -2 : nombre d'arguments inconnu
      *  0 : la fonction doit apparaître en notation infixe       *  0 : la fonction doit apparaître en notation infixe
      * >0 : la fonction apparaît comme une fonction normale       * >0 : la fonction apparaît comme une fonction normale
      */       */
   
     logical1                    lancement_interactif;      logical1                    lancement_interactif;
Line 2295  typedef struct processus Line 2346  typedef struct processus
   
     logical1                    processus_detache;      logical1                    processus_detache;
   
       enum t_type                 type_en_cours;
   
 /* Profilage                                            */  /* Profilage                                            */
   
     logical1                    profilage;      logical1                    profilage;
Line 2303  typedef struct processus Line 2356  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;
   
     // Mutex autorisant les fork()      // Mutex autorisant les fork()
     sem_t __PTR__               semaphore_fork;      sem_t __PTR__               semaphore_fork;
Line 2316  typedef struct processus Line 2370  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;
     integer8                    taille_pile_tampon;      integer8                    taille_pile_tampon;
Line 2334  typedef struct processus Line 2392  typedef struct processus
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 1024  #   define TAILLE_CACHE 1024
   #   define CACHE(type, nom) \
     integer8                    *objets_adr[TAILLE_CACHE];      type                        *objets_##nom[TAILLE_CACHE]; \
     int                         pointeur_adr;      int                         pointeur_##nom;
   
     logical8                    *objets_bin[TAILLE_CACHE];  #   define CACHE2(type, nom) \
     int                         pointeur_bin;      type                        *nom[TAILLE_CACHE]; \
       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_arbre_variables_partagees  
                                 *variables_partagees_noeud[TAILLE_CACHE];  
     int                         pointeur_variables_partagees_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_arbre_variables_partagees  
                                 **variables_tableau_noeuds_partages  
                                 [TAILLE_CACHE];  
     int                         pointeur_variables_tableau_noeuds_partages;  
 } 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)
     integer8                            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 2419  typedef struct fonction Line 2462  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
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2551  void instruction_elseif(struct_processus Line 2594  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 2791  void instruction_return(struct_processus Line 2835  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 2954  void instruction_yield(struct_processus Line 3000  void instruction_yield(struct_processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures    Procédures
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2979  void conversion_chaine(struct_processus Line 3025  void conversion_chaine(struct_processus
         unsigned char *chaine, unsigned char type);          unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(struct_processus *s_etat_processus,
           unsigned char **element, unsigned char *fonction);
 void conversion_format(struct_processus *s_etat_processus,  void conversion_format(struct_processus *s_etat_processus,
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(
         unsigned char *chaine_sortie, integer8 longueur);          unsigned char *chaine_entree, unsigned char *chaine_sortie,
           integer8 longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
 void copie_arbre_variables(struct_processus *s_etat_processus,  void copie_arbre_variables(struct_processus *s_etat_processus,
         struct_processus *s_nouvel_etat_processus);          struct_processus *s_nouvel_etat_processus);
Line 3143  int envoi_signal_thread(pthread_t tid, e Line 3191  int envoi_signal_thread(pthread_t tid, e
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions de sommation de vecteur dans perte de précision    Fonctions de sommation de vecteur dans perte de précision
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3175  real8 correlation_statistique(struct_mat Line 3223  real8 correlation_statistique(struct_mat
 real8 covariance_statistique(struct_matrice *s_matrice,  real8 covariance_statistique(struct_matrice *s_matrice,
         integer8 colonne_1, integer8 colonne_2,          integer8 colonne_1, integer8 colonne_2,
         unsigned char type, logical1 *erreur);          unsigned char type, logical1 *erreur);
 struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,  struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus,
         unsigned char type);          struct_matrice *s_matrice, unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus,
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
   struct_vecteur *sommation_colonne_statistique(
           struct_processus *s_etat_processus, struct_matrice *s_matrice,
         integer8 colonne);          integer8 colonne);
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice  struct_vecteur *sommation_produits_colonnes_statistiques(
           struct_processus *s_etat_processus, struct_matrice
         *s_matrice, integer8 colonne_1, integer8 colonne_2);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_statistique(struct_processus *s_etat_processus,
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
         unsigned char type);  struct_vecteur *variance_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice, unsigned char type);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Gestion des bibliothèques    Gestion des bibliothèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3220  unsigned char *analyse_algebrique(struct Line 3272  unsigned char *analyse_algebrique(struct
         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, integer8 longueur);          unsigned char *flux, integer8 longueur);
 unsigned char *chiffrement(const EVP_CIPHER *type_chiffrement,  unsigned char *chiffrement(struct_processus *s_etat_processus,
           const EVP_CIPHER *type_chiffrement,
         logical1 encodage, unsigned char *message, integer8 longueur_message,          logical1 encodage, unsigned char *message, integer8 longueur_message,
         unsigned char *clef, integer8 longueur_clef,          unsigned char *clef, integer8 longueur_clef,
         unsigned char *vecteur_initialisation,          unsigned char *vecteur_initialisation,
         integer8 *longueur_message_chiffre);          integer8 *longueur_message_chiffre);
 unsigned char *compactage(unsigned char *chaine);  unsigned char *compactage(struct_processus *s_etat_processus,
 unsigned char *conversion_majuscule(unsigned char *chaine);          unsigned char *chaine);
   unsigned char *conversion_majuscule(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *date_compilation();  unsigned char *date_compilation(struct_processus *s_etat_processus);
 unsigned char *extraction_chaine(unsigned char *chaine, integer8 i, integer8 j);  unsigned char *extraction_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 i, integer8 j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
         struct_objet *s_objet);          struct_objet *s_objet);
 unsigned char *formateur_fichier(struct_processus *s_etat_processus,  unsigned char *formateur_fichier(struct_processus *s_etat_processus,
Line 3256  unsigned char *formateur_reel(struct_pro Line 3312  unsigned char *formateur_reel(struct_pro
 unsigned char *messages(struct_processus *s_etat_processus);  unsigned char *messages(struct_processus *s_etat_processus);
 unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,  unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
         unsigned char *chaine, integer8 position);          unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
         *s_etat_processus);          *s_etat_processus);
 unsigned char *reencodage(struct_processus *s_etat_processus,  unsigned char *reencodage(struct_processus *s_etat_processus,
Line 3308  logical1 initialisation_fichier_acces_in Line 3365  logical1 initialisation_fichier_acces_in
         sqlite3 *sqlite, integer8 position_clef, logical1 binaire);          sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
 logical1 lancement_thread_signaux(struct_processus *s_etat_processus);  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_variables_par_niveau(struct_processus *s_etat_processus);  logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus);
Line 3368  ssize_t write_atomic(struct_processus *s Line 3427  ssize_t write_atomic(struct_processus *s
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, ...);
   #ifndef RPLARGS
   int association_etat_processus_readline();
   #endif
 int interruption_violation_access(void *adresse_fautive, int gravite);  int interruption_violation_access(void *adresse_fautive, int gravite);
 #ifndef RPLARGS  #ifndef RPLARGS
   int initialisation_etat_processus_readline();
   int liberation_etat_processus_readline();
 integer8 liste_variables(struct_processus *s_etat_processus,  integer8 liste_variables(struct_processus *s_etat_processus,
         struct_tableau_variables *tableau);          struct_tableau_variables *tableau);
 integer8 nombre_variables(struct_processus *s_etat_processus);  integer8 nombre_variables(struct_processus *s_etat_processus);
 int readline_analyse_syntaxique(int count, int key);  int readline_analyse_syntaxique(int count, int key);
 int readline_effacement(int count, int key);  int readline_effacement(int count, int key);
 #endif  #endif
   int std_fprintf(file *flux, const char *format, ...);
 int tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...);          const char *format, ...);
 int valsprintf(unsigned char **strp, const char *fmt, va_list ap);  int valsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, va_list ap);
 int wrapper_instruction_intrinseque(void (*fonction)(),  int wrapper_instruction_intrinseque(void (*fonction)(),
         struct_rpl_arguments *rpl_arguments);          struct_rpl_arguments *rpl_arguments);
   
Line 3397  unsigned char longueur_entiers_binaires( Line 3464  unsigned char longueur_entiers_binaires(
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions retournant un INTEGER*8 (valeur binaire non signée)    Fonctions retournant un INTEGER*8 (valeur binaire non signée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3421  integer8 position_caractere_de_chaine(st Line 3488  integer8 position_caractere_de_chaine(st
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)    Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3432  struct_liste_chainee *analyse_rpn(struct Line 3499  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 3494  struct_liste_variables_partagees *recher Line 3574  struct_liste_variables_partagees *recher
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant les arbres de simplification    Fonctions gérant la complétion automatique
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS  
 struct_arbre *creation_arbre(struct_processus *s_etat_processus,  
         struct_objet **t_objets, integer8 indice, integer8 indice_maximal);  
 void liberation_arbre(struct_processus *s_etat_processus,  
         struct_arbre *s_noeud);  
 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  
   
 /*  
 --------------------------------------------------------------------------------  
   Fonctions gérant la complétion automatique  
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3522  char **completion_matches(); Line 3586  char **completion_matches();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Arithmétique    Arithmétique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3566  void f77soustractionrc_(real8 *ra, compl Line 3630  void f77soustractionrc_(real8 *ra, compl
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Trigonométrie complexe    Trigonométrie complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3663  void zgeev_(unsigned char *calcul_vp_gau Line 3727  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 3676  void zggev_(unsigned char *calcul_vp_gau Line 3740  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 3691  void zgelsd_(integer4 *nombre_lignes_a, Line 3755  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 3752  void zgees_(unsigned char *calcul_vecteu Line 3816  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 3773  void zgelsy_(integer4 *m, integer4 *n, i Line 3837  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.214  
changed lines
  Added in v.1.258

CVSweb interface <joel.bertrand@systella.fr>