Diff for /rpl/src/rpl.h between versions 1.76 and 1.172

version 1.76, 2011/03/06 16:44:15 version 1.172, 2012/07/05 08:07:41
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.21    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 23 Line 23
 #ifndef INCLUSION_RPL  #ifndef INCLUSION_RPL
 #define INCLUSION_RPL  #define INCLUSION_RPL
   
 #define _GNU_SOURCE  #ifndef __RPLCAS
 #define _POSIX_C_SOURCE     200112L  #   define _GNU_SOURCE
   #   define _XOPEN_SOURCE        700
   #endif
   
 #define _REENTRANT  #define _REENTRANT
   
 #ifdef Darwin  #ifndef __RPLCAS
 #   define  _DARWIN_C_SOURCE  #   ifdef Darwin
 #endif  #       define  _DARWIN_C_SOURCE
   #   endif
   
 #ifdef OpenBSD  #   ifdef OpenBSD
 #   define _BSD_SOURCE  #       define _BSD_SOURCE
   #   endif
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
 #   define _BSD_SOURCE  #   ifndef __RPLCAS
 #   define _XOPEN_SOURCE    600  #       define _BSD_SOURCE
   #   endif
   
 #   include <types.h>  #   include <types.h>
     enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };      enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
Line 65 Line 71
 #include <syslog.h>  #include <syslog.h>
 #include <errno.h>  #include <errno.h>
 #include <stdarg.h>  #include <stdarg.h>
   #include <poll.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   include <sys/mman.h>  #   include <sys/mman.h>
Line 85 Line 92
 #   include <dlfcn.h>  #   include <dlfcn.h>
 #   include <fcntl.h>  #   include <fcntl.h>
 #   include <pthread.h>  #   include <pthread.h>
   #   include <regex.h>
   
 #   ifdef OS2  #   ifdef OS2
 #       undef pthread_mutexattr_settype  #       undef pthread_mutexattr_settype
Line 92 Line 100
 #   endif  #   endif
   
 #   include <pwd.h>  #   include <pwd.h>
   #   ifdef SHARED_MEMORY
 #   ifdef _BROKEN_SIGINFO  
 #       include <sys/ipc.h>  
 #       include <sys/shm.h>  #       include <sys/shm.h>
 #   endif  #   endif
   
Line 119 Line 125
                 ULONG   *nopened;                  ULONG   *nopened;
                 ULONG   allocated;                  ULONG   allocated;
             } sem_t;              } sem_t;
 #       else  #       else // IPCS_SYSV
             typedef struct              typedef struct
             {              {
                 int             sem;                  int             sem;
                   int             alloue;
                 unsigned char   *path;                  unsigned char   *path;
                 pid_t           pid;                  pid_t           pid;
                   pthread_t       tid;
             } sem_t;              } sem_t;
 #       endif  #       endif
   
 #       define SEM_FAILED   NULL  #       ifndef SEM_FAILED
   #           define SEM_FAILED   NULL
   #       endif
   
         sem_t *sem_open_SysV(const char *nom, int oflag, ...);          sem_t *sem_open_SysV(const char *nom, int oflag, ...);
         int sem_init_SysV(sem_t *sem, int shared, unsigned int value);          int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
         int sem_close_SysV(sem_t *sem);          int sem_close_SysV(sem_t *sem);
         int sem_wait_SysV(sem_t *sem);          int sem_wait_SysV(sem_t *sem);
         int sem_trywait_SysV(sem_t *sem);          int sem_trywait_SysV(sem_t *sem);
           int sem_timedwait_SysV(sem_t *sem, struct timespec *ts);
         int sem_post_SysV(sem_t *sem);          int sem_post_SysV(sem_t *sem);
         int sem_getvalue_SysV(sem_t *sem, int *value);          int sem_getvalue_SysV(sem_t *sem, int *value);
         int sem_unlink_SysV(const char *nom);          int sem_unlink_SysV(char *nom);
         int sem_destroy_SysV(sem_t *sem);          int sem_destroy_SysV(sem_t *sem);
 #   endif  #   endif
   
Line 155 Line 166
   
 #   include "openssl/evp.h"  #   include "openssl/evp.h"
 #   include "sqlite3.h"  #   include "sqlite3.h"
   #   include "sigsegv.h"
   #   ifdef OS2
           // Bug de libsigsegv
   #       undef HAVE_STACK_OVERFLOW_RECOVERY
   #   endif
   
 #   define HAVE_INLINE  #   define HAVE_INLINE
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
Line 200 Line 216
 #   endif  #   endif
 #endif  #endif
   
   #ifdef MAIN_RPL
   #   define __EXTERN__
   #   define __STATIC_MUTEX_INITIALIZATION__ = PTHREAD_MUTEX_INITIALIZER
   #else
   #   define __EXTERN__                       extern
   #   define __STATIC_MUTEX_INITIALIZATION__
   #endif
   
 /*  /*
 ================================================================================  ================================================================================
   Bugs spécifiques    Bugs spécifiques
 ================================================================================  ================================================================================
 */  */
   
 #ifdef _BROKEN_SIGINFO  // Néant
 #   define SIGHANDLER_ARGS  int signal  
 #   ifdef SA_SIGINFO  
 #       undef SA_SIGINFO  
 #   endif  
 #   define SA_SIGINFO   0  
   
 #   ifndef __BROKEN_SIGINFO_ROUTINES__  
   
 // pthread_kill() est une macro sous OS/2.  /*
 #       ifdef pthread_kill  ================================================================================
 #           undef pthread_kill    TYPES
 #       endif  ================================================================================
   */
   
 #       define kill(a, b)           kill_broken_siginfo(a, b)  typedef FILE                    file;
 #       define pthread_kill(a, b)   pthread_kill_broken_siginfo(a, b)  typedef unsigned char           t_8_bits;
 #   endif  
   
     int kill_broken_siginfo(pid_t pid, int signal);  #ifndef RPLARGS
     int pthread_kill_broken_siginfo(pthread_t tid, int signal);  #   include "rpltypes-conv.h"
     pid_t origine_signal(int signal);  
     int queue_in(pid_t pid, int signal);  
 #else  #else
 #   define SIGHANDLER_ARGS  int signal, siginfo_t *siginfo, void *context  #   include "rpltypes.h"
 #endif  #endif
   
 #ifdef OpenBSD  enum signaux_rpl
 #   ifdef PTHREAD_SCOPE_SYSTEM  {
 #       undef PTHREAD_SCOPE_SYSTEM      rpl_signull = 0,
       rpl_sigint,
       rpl_sigterm,
       rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
       rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                           // SUSPEND
       rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                           // FUSE. (FSTOP)
       rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                           // avec FABORT)
       rpl_sigurg,         // Signal d'arrêt urgent
       rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                           // envoyée depuis le père
       rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
       rpl_sighup,
       rpl_sigtstp,
       rpl_sigexcept,
       rpl_sigmax
   };
   
   #define LONGUEUR_QUEUE_SIGNAUX          1024
   
   // Une structure s_queue_signaux est créée par processus (et non par thread).
   // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit
   // accessible à la fois du père et des fils.
   
   #ifndef RPLARGS
   typedef struct queue_signaux
   {
   #   ifndef IPCS_SYSV
   #       ifndef SEMAPHORES_NOMMES
               sem_t               semaphore;
               sem_t               signalisation;
   #       endif
   #   else
           sem_t                   semaphore;
           sem_t                   signalisation;
   #   endif
   
       volatile int                pointeur_lecture;
       volatile int                pointeur_ecriture;
       pthread_t                   thread_signaux;
       volatile logical1           requete_arret;
   
       volatile struct
       {
           pid_t                   pid;
           enum signaux_rpl        signal;
       }                           queue[LONGUEUR_QUEUE_SIGNAUX];
   } struct_queue_signaux;
   
   __EXTERN__ struct_queue_signaux     *s_queue_signaux;
   __EXTERN__ int                      f_queue_signaux;
   
   #   ifdef SEMAPHORES_NOMMES
           __EXTERN__ sem_t            *semaphore_queue_signaux;
           __EXTERN__ sem_t            *semaphore_signalisation;
 #   endif  #   endif
 #   define PTHREAD_SCOPE_SYSTEM 0  
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
Line 254  union semun Line 324  union semun
 };  };
 #endif  #endif
   
   #ifndef RTLD_LOCAL
   #   define RTLD_LOCAL       0
   #endif
   
   #ifndef SIGSTKSZ
   #   define SIGSTKSZ         65536
   #endif
   
 /*  /*
 ================================================================================  ================================================================================
Line 266  union semun Line 343  union semun
 #   define sem_destroy(a)       sem_destroy_SysV(a)  #   define sem_destroy(a)       sem_destroy_SysV(a)
 #   define sem_wait(a)          sem_wait_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_post(a)          sem_post_SysV(a)  #   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__)
Line 286  union semun Line 364  union semun
 //  SIGINT  //  SIGINT
 //  SIGTSTP  //  SIGTSTP
 //  SIGCONT  //  SIGCONT
 //  SIGURG  
 //  SIGPIPE  //  SIGPIPE
   //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
   //  SIGHUP
 //  SIGALRM  //  SIGALRM
   
 //  Arrêt par STOP  #   define SIGTEST                  255
 #   define SIGFSTOP                 SIGUSR1  
 //  Démarrage d'un processus fils  
 #   define SIGSTART                 SIGUSR2  
 //  Injection de données  
 #   define SIGINJECT                SIGQUIT  
 //  Arrêt général  
 #   ifndef OpenBSD  
 //  La libpthread d'OpenBSD utilise SIGPROF  
 #       define SIGABORT             SIGPROF  
 #   else  
 #       define SIGABORT             SIGTHR  
 #   endif  
 //  Arrêt d'un processus fils depuis autre chose que STOP  
 #   if defined(Darwin) || defined(OpenBSD)  
 #       define SIGFABORT            SIGINFO  
 #   else  
 #       define SIGFABORT            SIGPOLL  
 #   endif  
   
 //  Nombre d'interruptions disponibles  //  Nombre d'interruptions disponibles
 #   define d_NOMBRE_INTERRUPTIONS   64  #   define d_NOMBRE_INTERRUPTIONS   64
Line 351  union semun Line 412  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   TYPES  
 ================================================================================  
 */  
   
 typedef FILE                    file;  
 typedef unsigned char           t_8_bits;  
   
 #ifndef RPLARGS  
 #   include "rpltypes-conv.h"  
 #else  
 #   include "rpltypes.h"  
 #endif  
   
 /*  
 ================================================================================  
   Variables globales    Variables globales
 ================================================================================  ================================================================================
 */  */
Line 375  typedef unsigned char   t_8_bits; Line 421  typedef unsigned char   t_8_bits;
 #       define LONGUEUR_NOM_SEMAPHORE   64  #       define LONGUEUR_NOM_SEMAPHORE   64
 #   endif  #   endif
   
 #   ifndef MAIN_RPL  #   ifdef SEMAPHORES_NOMMES
 #       ifdef _BROKEN_SIGINFO  #       define __PTR__      *
             extern int              *fifos_signaux;  
 #       endif  
   
         extern jmp_buf              contexte;  
         extern jmp_buf              contexte_initial;  
   
 #       ifdef SEMAPHORES_NOMMES  
         extern pthread_mutex_t      mutex_sem;  
 #       endif  
   
         extern pthread_key_t        semaphore_fork_processus_courant;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_liste_threads;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux_atomique;  
   
 #       ifdef SEMAPHORES_NOMMES  
         // 0 -> liste_threads  
         // 1 -> gestionnaire_signaux  
         // 2 -> gestionnaire_signaux_atomique  
         // 3 -> &((*s_etat_processus).semaphore_fork)  
             extern unsigned char    noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];  
             extern sem_t            *semaphores_nommes[4];  
 #       endif  
 #   else  #   else
 #       ifdef _BROKEN_SIGINFO  #       define __PTR__
             int                     *fifos_signaux;  #   endif
 #       endif  
   
         jmp_buf                     contexte;      __EXTERN__ jmp_buf              contexte_ecriture;
         jmp_buf                     contexte_initial;      __EXTERN__ jmp_buf              contexte_impression;
       __EXTERN__ jmp_buf              contexte_initial;
       __EXTERN__ jmp_buf              contexte_processus;
       __EXTERN__ jmp_buf              contexte_thread;
   
 #       ifdef SEMAPHORES_NOMMES      __EXTERN__ volatile int         signal_test;
         pthread_mutex_t             mutex_sem = PTHREAD_MUTEX_INITIALIZER;  
 #       endif  
   
         pthread_key_t               semaphore_fork_processus_courant;      __EXTERN__ pid_t                pid_processus_pere;
   
         sem_t  #   ifdef SEMAPHORES_NOMMES
 #       ifdef SEMAPHORES_NOMMES      __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
         *  #   endif
 #       endif  
                                     semaphore_liste_threads;  
   
         sem_t      __EXTERN__ pthread_mutex_t      mutex_liste_threads
 #       ifdef SEMAPHORES_NOMMES                                              __STATIC_MUTEX_INITIALIZATION__;
         *      __EXTERN__ pthread_mutex_t      mutex_gestionnaires_signaux_atomique
 #       endif                                              __STATIC_MUTEX_INITIALIZATION__;
                                     semaphore_gestionnaires_signaux;  
   
         sem_t      __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux_atomique;  
   
 #       ifdef SEMAPHORES_NOMMES      __EXTERN__ volatile int         routine_recursive;
             unsigned char           noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];  
             sem_t                   *semaphores_nommes[4];  
 #       endif  
 #   endif  
 #endif  #endif
   
 #ifdef SEMAPHORES_NOMMES  #ifdef SEMAPHORES_NOMMES
 enum t_semaphore    { sem_liste_threads = 0,  #define SEM_FORK            0
         sem_gestionnaires_signaux = 1,  #define SEM_QUEUE           1
         sem_gestionnaires_signaux_atomique = 2,  #define SEM_SIGNAUX         2
         sem_fork = 3 };  #define SEM_SIGNALISATION   3
   sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);
 sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore);  sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);
 int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore);  int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);
   int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre);
 int sem_getvalue2(sem_t *semaphore, int *valeur);  int sem_getvalue2(sem_t *semaphore, int *valeur);
   sem_t *sem_open2(pid_t pid, int ordre);
   
   // Le mutex est là uniquement pour pouvoir émuler le comportement
   // de sem_getvalue() sur un système comme MacOS X qui ne possède pas
   // cette fonction.
   
 #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)  #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
 #define sem_post(semaphore) \  #define sem_post(semaphore) \
Line 494  int sem_getvalue2(sem_t *semaphore, int Line 497  int sem_getvalue2(sem_t *semaphore, int
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  #define ufprintf(flux, ...) transliterated_fprintf(NULL, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
   
 // Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr.  
 // Cela évite aux messages envoyés par les gestionnaires de signaux d'être  
 // indéfiniment bloqués.  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
             while((desc = fopen(__VA_ARGS__)) == NULL) \              while((desc = fopen(__VA_ARGS__)) == NULL) \
Line 508  int sem_getvalue2(sem_t *semaphore, int Line 507  int sem_getvalue2(sem_t *semaphore, int
 #   define fclose(...) ({ int ios; \  #   define fclose(...) ({ int ios; \
             while((ios = fclose(__VA_ARGS__)) != 0) \              while((ios = fclose(__VA_ARGS__)) != 0) \
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })              { if ((errno != EINTR) && (errno != 0)) break; } ios; })
 #   define fread(...) ({ int ios; \  
             while((ios = fread(__VA_ARGS__)) < 0) \  
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })  
 #   define fflush(flux) ({ int ios; \  #   define fflush(flux) ({ int ios; \
             while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \              while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })              { if ((errno != EINTR) && (errno != 0)) break; } ios; })
Line 786  pid_t debug_fork(); Line 782  pid_t debug_fork();
 #   define d_es_contexte                        __erreur(2013)  #   define d_es_contexte                        __erreur(2013)
 #   define d_es_somme_controle                  __erreur(2014)  #   define d_es_somme_controle                  __erreur(2014)
 #   define d_es_semaphore                       __erreur(2015)  #   define d_es_semaphore                       __erreur(2015)
   #   define d_es_mutex_acquis_autre_thread       __erreur(2016)
 #endif  #endif
   
 /*  /*
Line 922  pid_t debug_fork(); Line 919  pid_t debug_fork();
 #   define d_ex_clef_inexistante                __erreur(80)  #   define d_ex_clef_inexistante                __erreur(80)
 #   define d_ex_nom_implicite                   __erreur(81)  #   define d_ex_nom_implicite                   __erreur(81)
 #   define d_ex_version_bibliotheque            __erreur(82)  #   define d_ex_version_bibliotheque            __erreur(82)
   #   define d_ex_creation_variable_globale       __erreur(83)
   #   define d_ex_erreur_interne_rplcas           __erreur(84)
   #   define d_ex_fichier_corrompu                __erreur(85)
   #   define d_ex_mutex_acquis_autre_thread       __erreur(86)
   #   define d_ex_expression_reguliere            __erreur(87)
   #   define d_ex_instruction_indisponible        __erreur(88)
 #endif  #endif
   
   
Line 972  pid_t debug_fork(); Line 975  pid_t debug_fork();
 #define VIN __RPL_VIN  #define VIN __RPL_VIN
 #define VRL __RPL_VRL  #define VRL __RPL_VRL
   
   enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
Line 1108  typedef struct fichier Line 1112  typedef struct fichier
 typedef struct rpl_mutex  typedef struct rpl_mutex
 {  {
     pthread_mutex_t     mutex;      pthread_mutex_t     mutex;
       pthread_t           tid;
 } struct_mutex;  } struct_mutex;
 #endif  #endif
   
Line 1181  typedef struct descripteur_fichier Line 1186  typedef struct descripteur_fichier
     pid_t                       pid;      pid_t                       pid;
     pthread_t                   tid;      pthread_t                   tid;
   
     file                        *descripteur_c;      union
     sqlite3                     *descripteur_sqlite;      {
           file                    *descripteur_c;
           sqlite3                 *descripteur_sqlite;
       };
 } struct_descripteur_fichier;  } struct_descripteur_fichier;
 #endif  #endif
   
Line 1277  typedef struct liste_chainee Line 1285  typedef struct liste_chainee
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Structure de gestion des signaux en provenance de rplsignal
   --------------------------------------------------------------------------------
   */
   
   #define d_NOMBRE_SIGNAUX                64
   
   typedef struct gestion_signaux
   {
       unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];
   
       /*
        * 'I' : signal ignoré
        * 'Q' : signal mis en queue pour un traitement ultérieur
        * 'N' : traitement normal du signal
        */
   
       integer8                    queue_signaux[d_NOMBRE_SIGNAUX];
       integer8                    nombre_signaux_en_queue;
       struct_objet                *corps_signaux[d_NOMBRE_SIGNAUX];
   
       pthread_mutex_t             mutex;
   } struct_gestion_signaux;
   
   #ifndef MAIN_RPL
   #   define __STATIC_GESTION_SIGNAUX__
   #else
   #   define __STATIC_GESTION_SIGNAUX__ = { .mutex = PTHREAD_MUTEX_INITIALIZER }
   #endif
   
   __EXTERN__ volatile struct_gestion_signaux signaux_externes
           __STATIC_GESTION_SIGNAUX__;
   
   
   /*
   --------------------------------------------------------------------------------
   Structure liste profilage    Structure liste profilage
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 1378  typedef struct descripteur_thread Line 1421  typedef struct descripteur_thread
     logical1                    processus_detache;      logical1                    processus_detache;
     logical1                    destruction_objet;      logical1                    destruction_objet;
   
     sigset_t                    oldset;  
     sigset_t                    set;  
   
     volatile signed long        nombre_references;      volatile signed long        nombre_references;
 } struct_descripteur_thread;  } struct_descripteur_thread;
   
Line 1670  typedef struct rpl_arguments Line 1710  typedef struct rpl_arguments
     void                        *s_etat_processus;      void                        *s_etat_processus;
 } struct_rpl_arguments;  } struct_rpl_arguments;
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des instructions intrinsèques
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct instruction
   {
       struct instruction      **noeuds;
       void                    (*feuille)(struct processus *);
   } struct_instruction;
   #endif
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des variables variable globales et locales
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct arbre_variables
   {
       unsigned int            noeuds_utilises;
       signed int              indice_tableau_pere;
       struct arbre_variables  *noeud_pere;
       struct arbre_variables  **noeuds;
       struct liste_variables  *feuille;
   } struct_arbre_variables;
   
   typedef struct tableau_variables
   {
       unsigned char           origine;
       unsigned char           *nom;       // pointeur sur la struct_variable
                                           // réelle et non copie de la chaîne
       unsigned long           niveau;
   
       struct_objet            *objet;     // pointeur sur l'objet et non copie
                                           // de l'objet.
   
       logical1                variable_verrouillee;
       union_position_variable variable_statique;
       union_position_variable variable_partagee;
   } struct_tableau_variables;
   
   typedef struct liste_variables
   {
       union
       {
           // Utilisation dans la gestion des variables
           struct_variable                 *variable;
           // Utilisation dans la pile système (variables par niveau)
           struct_liste_chainee            *liste;
       };
   
       struct arbre_variables              *noeud_pere;
       struct arbre_variables              *noeud;
       struct liste_variables              *suivant;
       struct liste_variables              *precedent;
   } struct_liste_variables;
   
   #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1716  typedef struct processus Line 1818  typedef struct processus
   
     int                         *pointeurs_caracteres;      int                         *pointeurs_caracteres;
     int                         nombre_caracteres;      int                         nombre_caracteres;
     struct instruction          *arbre_instructions;      struct_instruction          *arbre_instructions;
   
 /* Requetes                                             */  /* Requetes                                             */
   
Line 1759  typedef struct processus Line 1861  typedef struct processus
     pthread_t                   thread_fusible;      pthread_t                   thread_fusible;
     pthread_t                   thread_surveille_par_fusible;      pthread_t                   thread_surveille_par_fusible;
   
 #   if !defined(Cygwin)      volatile int                pointeur_signal_ecriture;
 #       if !(OpenBSD)      volatile int                pointeur_signal_lecture;
             stack_t             pile_signal;      volatile enum signaux_rpl   signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
 #       else      volatile logical1           demarrage_fils;
 #           ifdef SA_ONSTACK      volatile logical1           redemarrage_processus;
 #               undef SA_ONSTACK  
 #           endif  
 #           define SA_ONSTACK   0  
 #       endif  
 #   else  
 #       define SA_ONSTACK       0  
 #       define RTLD_LOCAL       0  
 #   endif  
   
 /* Contextes                                            */  /* Contextes                                            */
   
Line 1780  typedef struct processus Line 1874  typedef struct processus
   
 /* Variables                                            */  /* Variables                                            */
   
     struct_variable             *s_liste_variables;      // La liste des variables par niveau est doublement chaînée.
     unsigned long               nombre_variables;      // À tout moment, elle pointe sur le niveau le plus haut existant et
     unsigned long               nombre_variables_allouees;      // l_liste_variable_par_niveau->precedent renvoie la liste des
       // définitions. l_liste_variable_par_niveau->precedent->precedent pointe
       // sur la liste des variables globales.
       //
       // À l'initialisation :
       // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
       // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
   
       struct_arbre_variables      *s_arbre_variables;
       struct_liste_variables      *l_liste_variables_par_niveau;
       logical1                    niveau_supprime;
   
       struct_variable             *pointeur_variable_courante;
       struct_liste_variables      *pointeur_feuille_courante;
   
       int                         *pointeurs_caracteres_variables;
       int                         nombre_caracteres_variables;
   
     struct_variable_statique    *s_liste_variables_statiques;      struct_variable_statique    *s_liste_variables_statiques;
     unsigned long               nombre_variables_statiques;      unsigned long               nombre_variables_statiques;
Line 1793  typedef struct processus Line 1903  typedef struct processus
   
     unsigned long               niveau_courant;      unsigned long               niveau_courant;
     unsigned long               niveau_initial;      unsigned long               niveau_initial;
     unsigned long               position_variable_courante;  
     unsigned long               position_variable_statique_courante;      unsigned long               position_variable_statique_courante;
   
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
Line 2059  typedef struct processus Line 2168  typedef struct processus
     gsl_rng                     *generateur_aleatoire;      gsl_rng                     *generateur_aleatoire;
     const gsl_rng_type          *type_generateur_aleatoire;      const gsl_rng_type          *type_generateur_aleatoire;
   
       void                        *contexte_cas;
   
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
   
     /*      /*
Line 2081  typedef struct processus Line 2192  typedef struct processus
   
     pid_t                       pid_processus_pere;      pid_t                       pid_processus_pere;
     pthread_t                   tid_processus_pere;      pthread_t                   tid_processus_pere;
       pthread_t                   tid;
   
     logical1                    processus_detache;      logical1                    processus_detache;
   
Line 2096  typedef struct processus Line 2208  typedef struct processus
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
     pthread_mutex_t             mutex_allocation;      pthread_mutex_t             mutex_allocation;
   
     // Sémaphore autorisant les fork()      // Mutex autorisant les fork()
     sem_t      sem_t __PTR__               semaphore_fork;
 #   ifdef SEMAPHORES_NOMMES  
     *  
 #   endif  
                                 semaphore_fork;  
   
 /* Mutexes                                          */  /* Mutexes                                          */
   
     struct_liste_chainee        *liste_mutexes;      struct_liste_chainee        *liste_mutexes;
     pthread_mutex_t             protection_liste_mutexes;      pthread_mutex_t             protection_liste_mutexes;
   
   /* Drapeau nécessaire à RESTART                 */
   
       volatile logical1           requete_redemarrage;
   
 /* Gestion optimisée de la mémoire                  */  /* Gestion optimisée de la mémoire                  */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
Line 2121  typedef struct processus Line 2233  typedef struct processus
     unsigned long               taille_pile_objets;      unsigned long               taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   ifndef DEBUG_MALLOC  #   define TAILLE_CACHE 16384
 #       define TAILLE_CACHE 16384  
 #   else  
 #       define TAILLE_CACHE 4  
 #   endif  
   
     unsigned long               *objets_adr[TAILLE_CACHE];      unsigned long               *objets_adr[TAILLE_CACHE];
     int                         pointeur_adr;      int                         pointeur_adr;
Line 2159  typedef struct processus Line 2267  typedef struct processus
   
     struct_liste_chainee        *maillons[TAILLE_CACHE];      struct_liste_chainee        *maillons[TAILLE_CACHE];
     int                         pointeur_maillons;      int                         pointeur_maillons;
 } struct_processus;  
 #endif  
   
 /*      struct_arbre_variables      *variables_noeud[TAILLE_CACHE];
 --------------------------------------------------------------------------------      int                         pointeur_variables_noeud;
   Structures instruction intrinsèque  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS      struct_liste_variables      *variables_feuille[TAILLE_CACHE];
 typedef struct instruction      int                         pointeur_variables_feuille;
 {  
     struct instruction      **noeud;      struct_variable             *variables_variable[TAILLE_CACHE];
     void                    (*feuille)(struct_processus *);      int                         pointeur_variables_variable;
 } struct_instruction;  
 #endif  
   
       struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];
       int                         pointeur_variables_tableau_noeuds;
   } struct_processus;
   #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 2212  typedef struct fonction Line 2317  typedef struct fonction
 // BEGIN C PROTOTYPES  // BEGIN C PROTOTYPES
 void instruction_sensible_e(struct_processus *s_etat_processus);  void instruction_sensible_e(struct_processus *s_etat_processus);
 void instruction_sensible_i(struct_processus *s_etat_processus);  void instruction_sensible_i(struct_processus *s_etat_processus);
   void instruction_sensible_infinity(struct_processus *s_etat_processus);
   
 void instruction_abort(struct_processus *s_etat_processus);  void instruction_abort(struct_processus *s_etat_processus);
 void instruction_abs(struct_processus *s_etat_processus);  void instruction_abs(struct_processus *s_etat_processus);
Line 2408  void instruction_in(struct_processus *s_ Line 2514  void instruction_in(struct_processus *s_
 void instruction_incr(struct_processus *s_etat_processus);  void instruction_incr(struct_processus *s_etat_processus);
 void instruction_indep(struct_processus *s_etat_processus);  void instruction_indep(struct_processus *s_etat_processus);
 void instruction_input(struct_processus *s_etat_processus);  void instruction_input(struct_processus *s_etat_processus);
   void instruction_infinity(struct_processus *s_etat_processus);
 void instruction_inquire(struct_processus *s_etat_processus);  void instruction_inquire(struct_processus *s_etat_processus);
 void instruction_int(struct_processus *s_etat_processus);  void instruction_int(struct_processus *s_etat_processus);
 void instruction_interrupt(struct_processus *s_etat_processus);  void instruction_interrupt(struct_processus *s_etat_processus);
Line 2431  void instruction_lcd_fleche(struct_proce Line 2538  void instruction_lcd_fleche(struct_proce
 void instruction_lchol(struct_processus *s_etat_processus);  void instruction_lchol(struct_processus *s_etat_processus);
 void instruction_le(struct_processus *s_etat_processus);  void instruction_le(struct_processus *s_etat_processus);
 void instruction_legv(struct_processus *s_etat_processus);  void instruction_legv(struct_processus *s_etat_processus);
   void instruction_limit(struct_processus *s_etat_processus);
 void instruction_line(struct_processus *s_etat_processus);  void instruction_line(struct_processus *s_etat_processus);
 void instruction_list_fleche(struct_processus *s_etat_processus);  void instruction_list_fleche(struct_processus *s_etat_processus);
 void instruction_ln(struct_processus *s_etat_processus);  void instruction_ln(struct_processus *s_etat_processus);
Line 2499  void instruction_pmax(struct_processus * Line 2607  void instruction_pmax(struct_processus *
 void instruction_pmin(struct_processus *s_etat_processus);  void instruction_pmin(struct_processus *s_etat_processus);
 void instruction_poke(struct_processus *s_etat_processus);  void instruction_poke(struct_processus *s_etat_processus);
 void instruction_polar(struct_processus *s_etat_processus);  void instruction_polar(struct_processus *s_etat_processus);
   void instruction_poll(struct_processus *s_etat_processus);
 void instruction_pos(struct_processus *s_etat_processus);  void instruction_pos(struct_processus *s_etat_processus);
 void instruction_pourcent(struct_processus *s_etat_processus);  void instruction_pourcent(struct_processus *s_etat_processus);
 void instruction_pourcent_ch(struct_processus *s_etat_processus);  void instruction_pourcent_ch(struct_processus *s_etat_processus);
Line 2555  void instruction_read(struct_processus * Line 2664  void instruction_read(struct_processus *
 void instruction_recode(struct_processus *s_etat_processus);  void instruction_recode(struct_processus *s_etat_processus);
 void instruction_recv(struct_processus *s_etat_processus);  void instruction_recv(struct_processus *s_etat_processus);
 void instruction_redraw(struct_processus *s_etat_processus);  void instruction_redraw(struct_processus *s_etat_processus);
   void instruction_regex(struct_processus *s_etat_processus);
 void instruction_relax(struct_processus *s_etat_processus);  void instruction_relax(struct_processus *s_etat_processus);
 void instruction_remove(struct_processus *s_etat_processus);  void instruction_remove(struct_processus *s_etat_processus);
 void instruction_res(struct_processus *s_etat_processus);  void instruction_res(struct_processus *s_etat_processus);
   void instruction_restart(struct_processus *s_etat_processus);
 void instruction_recall(struct_processus *s_etat_processus);  void instruction_recall(struct_processus *s_etat_processus);
 void instruction_regv(struct_processus *s_etat_processus);  void instruction_regv(struct_processus *s_etat_processus);
 void instruction_repeat(struct_processus *s_etat_processus);  void instruction_repeat(struct_processus *s_etat_processus);
Line 2623  void instruction_sqlquery(struct_process Line 2734  void instruction_sqlquery(struct_process
 void instruction_sqrt(struct_processus *s_etat_processus);  void instruction_sqrt(struct_processus *s_etat_processus);
 void instruction_sr(struct_processus *s_etat_processus);  void instruction_sr(struct_processus *s_etat_processus);
 void instruction_srb(struct_processus *s_etat_processus);  void instruction_srb(struct_processus *s_etat_processus);
   void instruction_srev(struct_processus *s_etat_processus);
 void instruction_sst(struct_processus *s_etat_processus);  void instruction_sst(struct_processus *s_etat_processus);
 void instruction_star_d(struct_processus *s_etat_processus);  void instruction_star_d(struct_processus *s_etat_processus);
 void instruction_star_h(struct_processus *s_etat_processus);  void instruction_star_h(struct_processus *s_etat_processus);
Line 2684  void instruction_t_vers_l(struct_process Line 2796  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_undo(struct_processus *s_etat_processus);  
 void instruction_unlock(struct_processus *s_etat_processus);  void instruction_unlock(struct_processus *s_etat_processus);
 void instruction_unprotect(struct_processus *s_etat_processus);  void instruction_unprotect(struct_processus *s_etat_processus);
 void instruction_until(struct_processus *s_etat_processus);  void instruction_until(struct_processus *s_etat_processus);
Line 2739  void affichage_pile(struct_processus *s_ Line 2850  void affichage_pile(struct_processus *s_
         niveau_courant);          niveau_courant);
 #endif  #endif
   
 void *allocation(struct_processus *s_etat_processus, enum t_type type);  
 void *allocation_maillon(struct_processus *s_etat_processus);  void *allocation_maillon(struct_processus *s_etat_processus);
   
 #ifndef RPLARGS  #ifndef RPLARGS
Line 2751  void appel_gnuplot(struct_processus *s_e Line 2861  void appel_gnuplot(struct_processus *s_e
 void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void cond(struct_processus *s_etat_processus,  void cond(struct_processus *s_etat_processus,
         struct_matrice *s_matrice, real8 *condition);          struct_matrice *s_matrice, real8 *condition);
   void conversion_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(unsigned char **element, unsigned char *fonction);
Line 2760  void conversion_hms_vers_decimal(real8 * Line 2872  void conversion_hms_vers_decimal(real8 *
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(unsigned char *chaine_entree, 
         unsigned char *chaine_sortie, unsigned long longueur);          unsigned char *chaine_sortie, unsigned long longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
   void copie_arbre_variables(struct_processus *s_etat_processus,
           struct_processus *s_nouvel_etat_processus);
 void correction_formateur_tex(struct_processus *s_etat_processus,  void correction_formateur_tex(struct_processus *s_etat_processus,
         unsigned char **ligne);          unsigned char **ligne);
 void depilement_pile_systeme(struct_processus *s_etat_processus);  void depilement_pile_systeme(struct_processus *s_etat_processus);
Line 2799  void impression_tex(struct_processus *s_ Line 2913  void impression_tex(struct_processus *s_
 void informations(struct_processus *s_etat_processus);  void informations(struct_processus *s_etat_processus);
 void initialisation_allocateur(struct_processus *s_etat_processus);  void initialisation_allocateur(struct_processus *s_etat_processus);
 void initialisation_completion(void);  void initialisation_completion(void);
   void initialisation_contexte_cas(struct_processus *s_etat_processus);
 void initialisation_drapeaux(struct_processus *s_etat_processus);  void initialisation_drapeaux(struct_processus *s_etat_processus);
 void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,  void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,
         logical1 initialisation_automatique, unsigned long int racine);          logical1 initialisation_automatique, unsigned long int racine);
 void initialisation_instructions(struct_processus *s_etat_processus);  void initialisation_instructions(struct_processus *s_etat_processus);
   void initialisation_variables(struct_processus *s_etat_processus);
 #endif  #endif
   
 void initialisation_objet(struct_objet *s_objet);  void initialisation_objet(struct_objet *s_objet);
Line 2815  void insertion_thread_surveillance(struc Line 2931  void insertion_thread_surveillance(struc
 void integrale_romberg(struct_processus *s_etat_processus,  void integrale_romberg(struct_processus *s_etat_processus,
         struct_objet *s_expression, unsigned char *variable,          struct_objet *s_expression, unsigned char *variable,
         real8 a, real8 b, real8 precision);          real8 a, real8 b, real8 precision);
 void interruption1(SIGHANDLER_ARGS);  void interface_cas(struct_processus *s_etat_processus,
 void interruption2(SIGHANDLER_ARGS);          enum t_rplcas_commandes commande);
 void interruption3(SIGHANDLER_ARGS);  void interruption1(int signal);
 void interruption4(SIGHANDLER_ARGS);  void interruption2(int signal);
 void interruption5(SIGHANDLER_ARGS);  void interruption3(int signal);
 void interruption6(SIGHANDLER_ARGS);  void interruption4(int signal);
 void interruption7(SIGHANDLER_ARGS);  void interruption5(int signal);
 void interruption8(SIGHANDLER_ARGS);  void interruption6(int signal);
 void interruption9(SIGHANDLER_ARGS);  void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);
 void interruption10(SIGHANDLER_ARGS);  
 void interruption11(SIGHANDLER_ARGS);  
 void inversion_matrice(struct_processus *s_etat_processus,  void inversion_matrice(struct_processus *s_etat_processus,
         struct_matrice *s_matrice);          struct_matrice *s_matrice);
 void lancement_daemon(struct_processus *s_etat_processus);  void lancement_daemon(struct_processus *s_etat_processus);
Line 2840  void liberation_maillon(struct_processus Line 2954  void liberation_maillon(struct_processus
 void liberation_allocateur(struct_processus *s_etat_processus);  void liberation_allocateur(struct_processus *s_etat_processus);
 void liberation_arbre_instructions(struct_processus *s_etat_processus,  void liberation_arbre_instructions(struct_processus *s_etat_processus,
         struct_instruction *arbre);          struct_instruction *arbre);
   void liberation_arbre_variables(struct_processus *s_etat_processus,
           struct_arbre_variables *arbre, logical1 definitions);
   void liberation_contexte_cas(struct_processus *s_etat_processus);
 void liberation_generateur_aleatoire(struct_processus *s_etat_processus);  void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
 void liberation_threads(struct_processus *s_etat_processus);  void liberation_threads(struct_processus *s_etat_processus);
 void liberation_profil(struct_processus *s_etat_processus);  void liberation_profil(struct_processus *s_etat_processus);
Line 2856  void retrait_thread(struct_processus *s_ Line 2973  void retrait_thread(struct_processus *s_
 void retrait_thread_surveillance(struct_processus *s_etat_processus,  void retrait_thread_surveillance(struct_processus *s_etat_processus,
         struct_descripteur_thread *s_argument_thread);          struct_descripteur_thread *s_argument_thread);
 void rplcore(struct_processus *s_etat_processus);  void rplcore(struct_processus *s_etat_processus);
   #endif
   
 void scrutation_injection(struct_processus *s_etat_processus);  void scrutation_injection(struct_processus *s_etat_processus);
   
   #ifndef RPLARGS
   void scrutation_interruptions(struct_processus *s_etat_processus);
 void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void *surveillance_processus(void *argument);  void *surveillance_processus(void *argument);
 void swap(void *variable_1, void *variable_2, unsigned long taille_octets);  void swap(void *variable_1, void *variable_2, unsigned long taille_octets);
Line 2884  void valeurs_singulieres(struct_processu Line 3006  void valeurs_singulieres(struct_processu
 void verrouillage_threads_concurrents(struct_processus *s_etat_processus);  void verrouillage_threads_concurrents(struct_processus *s_etat_processus);
 #endif  #endif
   
   /*
   --------------------------------------------------------------------------------
     Fonctions de gestion des signaux
   --------------------------------------------------------------------------------
   */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #ifdef _BROKEN_SIGINFO  void creation_queue_signaux(struct_processus *s_etat_processus);
 void creation_fifos_signaux(struct_processus *s_etat_processus);  void liberation_queue_signaux(struct_processus *s_etat_processus);
 void destruction_fifos_signaux(struct_processus *s_etat_processus);  void destruction_queue_signaux(struct_processus *s_etat_processus);
 void liberation_fifos_signaux(struct_processus *s_etat_processus);  int envoi_signal_contexte(struct_processus *s_etat_processus,
 #endif          enum signaux_rpl signal);
   int envoi_signal_processus(pid_t pid, enum signaux_rpl signal);
   int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);
 #endif  #endif
   
 /*  /*
Line 2910  complex16 sommation_vecteur_complexe(com Line 3040  complex16 sommation_vecteur_complexe(com
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home);  int rplinit(int argc, char *argv[], char *envp[],
           unsigned char ***resultats, char *rpl_home);
 #endif  #endif
   
 /*  /*
Line 2968  struct_liste_chainee *sauvegarde_argumen Line 3099  struct_liste_chainee *sauvegarde_argumen
 #ifndef RPLARGS  #ifndef RPLARGS
 unsigned char *analyse_algebrique(struct_processus *s_etat_processus,  unsigned char *analyse_algebrique(struct_processus *s_etat_processus,
         unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);          unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);
   unsigned char *analyse_flux(struct_processus *s_etat_processus,
           unsigned char *flux, long longueur);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
         *s_etat_processus);          *s_etat_processus);
 unsigned char *compactage(unsigned char *chaine);  unsigned char *compactage(unsigned char *chaine);
 unsigned char *conversion_majuscule(unsigned char *chaine);  unsigned char *conversion_majuscule(unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
   unsigned char *date_compilation();
 unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,  unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,
         unsigned long j);          unsigned long j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
Line 2982  unsigned char *formateur_fichier(struct_ Line 3116  unsigned char *formateur_fichier(struct_
         struct_objet *s_objet, struct_objet *s_format,          struct_objet *s_objet, struct_objet *s_format,
         long longueur, long longueur_champ, unsigned char format,          long longueur, long longueur_champ, unsigned char format,
         unsigned char type, long *longueur_effective, long *recursivite);          unsigned char type, long *longueur_effective, long *recursivite);
   unsigned char *formateur_flux(struct_processus *s_etat_processus,
           unsigned char *donnees, long *longueur);
 unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format);          long longueur, long longueur_champ, unsigned char format);
   unsigned char *formateur_fichier_binaire_nombre(struct_processus
           *s_etat_processus, void *valeur_numerique, unsigned char type,
           long longueur, long *longueur_conversion);
 unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format);          long longueur, long longueur_champ, unsigned char format);
Line 2993  unsigned char *formateur_nombre(struct_p Line 3132  unsigned char *formateur_nombre(struct_p
 unsigned char *formateur_reel(struct_processus *s_etat_processus,  unsigned char *formateur_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type);          void *valeur_numerique, unsigned char type);
 unsigned char *messages(struct_processus *s_etat_processus);  unsigned char *messages(struct_processus *s_etat_processus);
   unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(unsigned char *chaine);
 unsigned char *reencodage(struct_processus *s_etat_processus,  unsigned char *reencodage(struct_processus *s_etat_processus,
         unsigned char *chaine_entree, unsigned char *codage_entree,          unsigned char *chaine_entree, unsigned char *codage_entree,
Line 3015  logical1 caracteristiques_fichier(struct Line 3156  logical1 caracteristiques_fichier(struct
         unsigned long *unite);          unsigned long *unite);
 logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,  logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,
         unsigned char *type, unsigned char *somme_candidate);          unsigned char *type, unsigned char *somme_candidate);
   logical1 controle_integrite(struct_processus *s_etat_processus,
           unsigned char *executable_candidat, unsigned char *executable);
 logical1 creation_variable(struct_processus *s_etat_processus,  logical1 creation_variable(struct_processus *s_etat_processus,
         struct_variable *s_variable,          struct_variable *s_variable,
         unsigned char autorisation_creation_variable_statique,          unsigned char autorisation_creation_variable_statique,
Line 3066  logical1 ecriture_pipe(struct_processus Line 3209  logical1 ecriture_pipe(struct_processus
         struct_objet *s_objet);          struct_objet *s_objet);
 logical1 recherche_variable(struct_processus *s_etat_processus,  logical1 recherche_variable(struct_processus *s_etat_processus,
         unsigned char *nom_variable);          unsigned char *nom_variable);
   logical1 recherche_variable_globale(struct_processus *s_etat_processus,
           unsigned char *nom_variable);
 logical1 recherche_variable_partagee(struct_processus *s_etat_processus,  logical1 recherche_variable_partagee(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position,          unsigned char *nom_variable, union_position_variable position,
         unsigned char origine);          unsigned char origine);
Line 3076  logical1 test_cfsf(struct_processus *s_e Line 3221  logical1 test_cfsf(struct_processus *s_e
         unsigned char indice_drapeau);          unsigned char indice_drapeau);
 logical1 test_expression_rpn(unsigned char *chaine);  logical1 test_expression_rpn(unsigned char *chaine);
 logical1 test_fonction(unsigned char *chaine);  logical1 test_fonction(unsigned char *chaine);
   logical1 validation_chaine(unsigned char *chaine);
 #endif  #endif
   
 /*  /*
Line 3098  ssize_t write_atomic(struct_processus *s Line 3244  ssize_t write_atomic(struct_processus *s
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(unsigned char **strp, const char *fmt, ...);
   int interruption_violation_access(void *adresse_fautive, int gravite);
   #ifndef RPLARGS
   int liste_variables(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau, int position,
           struct_arbre_variables *l_element_courant);
   int nombre_variables(struct_processus *s_etat_processus,
           struct_arbre_variables *l_element_courant);
   int readline_analyse_syntaxique(int count, int key);
   int readline_effacement(int count, int key);
   #endif
 int tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
Line 3114  int wrapper_instruction_intrinseque(void Line 3270  int wrapper_instruction_intrinseque(void
   
 #ifndef RPLARGS  #ifndef RPLARGS
 unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);  unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);
 unsigned char recherche_longueur_optimale(integer8 parametre);  
 #endif  #endif
   
 /*  /*
Line 3135  logical8 masque_entiers_binaires(struct_ Line 3290  logical8 masque_entiers_binaires(struct_
   
 #ifndef RPLARGS  #ifndef RPLARGS
 integer8 occupation_memoire(struct_objet *s_objet);  integer8 occupation_memoire(struct_objet *s_objet);
   integer8 longueur_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
   integer8 position_caractere_de_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char *position);
 #endif  #endif
   
 /*  /*
Line 3179  struct_descripteur_fichier *descripteur_ Line 3338  struct_descripteur_fichier *descripteur_
 struct_objet *copie_objet(struct_processus *s_etat_processus,  struct_objet *copie_objet(struct_processus *s_etat_processus,
         struct_objet *s_objet, unsigned char type);          struct_objet *s_objet, unsigned char type);
   
   struct_objet *allocation(struct_processus *s_etat_processus, enum t_type type);
 #ifndef RPLARGS  #ifndef RPLARGS
 struct_objet *formateur_date(struct_processus *s_etat_processus,  struct_objet *formateur_date(struct_processus *s_etat_processus,
         struct timeval *temps);          struct timeval *temps);

Removed from v.1.76  
changed lines
  Added in v.1.172


CVSweb interface <joel.bertrand@systella.fr>