|
version 1.183, 2012/10/08 11:53:46
|
version 1.354, 2024/10/23 13:51:48
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.1.11 |
RPL/2 (R) version 4.1.36 |
| Copyright (C) 1989-2012 Dr. BERTRAND Joël |
Copyright (C) 1989-2024 Dr. BERTRAND Joël |
| |
|
| This file is part of RPL/2. |
This file is part of RPL/2. |
| |
|
|
Line 38
|
Line 38
|
| # ifdef OpenBSD |
# ifdef OpenBSD |
| # define _BSD_SOURCE |
# define _BSD_SOURCE |
| # endif |
# endif |
| |
|
| |
# ifdef FreeBSD |
| |
# define __BSD_VISIBLE 1 |
| |
# endif |
| #endif |
#endif |
| |
|
| #ifdef OS2 |
#ifdef OS2 |
|
Line 56
|
Line 60
|
| # define sched_yield(arg) |
# define sched_yield(arg) |
| #endif |
#endif |
| |
|
| |
#ifdef CYGWIN |
| |
# define SA_ONSTACK 0 |
| |
#endif |
| |
|
| |
#ifdef BROKEN_SIGSEGV |
| |
# undef HAVE_STACK_OVERFLOW_RECOVERY |
| |
# undef HAVE_SIGSEGV_RECOVERY |
| |
#endif |
| |
|
| |
#define DEBUG_TRACE uprintf("[%d/%X] %s(%d)\n", \ |
| |
getpid(), pthread_self(), __FILE__, __LINE__); |
| |
#define TEST_ABSENCE_FICHIER(nom) \ |
| |
{ int ios; struct stat *buf; ios = stat(nom, buf); \ |
| |
if (ios == 0) BUG(1, uprintf("File %s found!\n", nom)); } |
| |
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
|
Line 65
|
Line 83
|
| |
|
| #include <stdio.h> |
#include <stdio.h> |
| #include <stdlib.h> |
#include <stdlib.h> |
| |
#include <stdint.h> |
| #include <math.h> |
#include <math.h> |
| #include <string.h> |
#include <string.h> |
| #include <strings.h> |
#include <strings.h> |
|
Line 72
|
Line 91
|
| #include <errno.h> |
#include <errno.h> |
| #include <stdarg.h> |
#include <stdarg.h> |
| #include <poll.h> |
#include <poll.h> |
| |
#include <signal.h> |
| |
#include <sys/time.h> |
| |
#include <pthread.h> |
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| # include <sys/mman.h> |
# include <sys/mman.h> |
| # include <sys/time.h> |
|
| # include <sys/resource.h> |
# include <sys/resource.h> |
| # include <sys/select.h> |
# include <sys/select.h> |
| # include <sys/socket.h> |
# include <sys/socket.h> |
| # include <sys/stat.h> |
# include <sys/stat.h> |
| # include <sys/timeb.h> |
|
| # include <sys/types.h> |
# include <sys/types.h> |
| # include <sys/un.h> |
# include <sys/un.h> |
| # include <sys/wait.h> |
# include <sys/wait.h> |
|
Line 91
|
Line 111
|
| |
|
| # include <dlfcn.h> |
# include <dlfcn.h> |
| # include <fcntl.h> |
# include <fcntl.h> |
| # include <pthread.h> |
|
| # include <regex.h> |
# include <regex.h> |
| |
|
| # ifdef OS2 |
# ifdef OS2 |
|
Line 153
|
Line 172
|
| # endif |
# endif |
| |
|
| # include <setjmp.h> |
# include <setjmp.h> |
| # include <signal.h> |
|
| # include <termios.h> |
# include <termios.h> |
| # include <time.h> |
# include <time.h> |
| # include <unistd.h> |
# include <unistd.h> |
|
Line 163
|
Line 181
|
| # include "readline.h" |
# include "readline.h" |
| # include "termcap.h" |
# include "termcap.h" |
| # include "iconv.h" |
# include "iconv.h" |
| |
# include "zlib.h" |
| |
|
| # include "openssl/evp.h" |
# include "openssl/evp.h" |
| |
# ifndef RPLCXX |
| |
# ifndef OPENSSL_NO_MD2 |
| |
# include "openssl/md2.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_MD4 |
| |
# include "openssl/md4.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_MD5 |
| |
# include "openssl/md5.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_MDC2 |
| |
# include "openssl/mdc2.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_RIPEMD |
| |
# include "openssl/ripemd.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_SHA |
| |
# include "openssl/sha.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_WHIRLPOOL |
| |
# include "openssl/whrlpool.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_AES |
| |
# include "openssl/aes.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_CAMELLIA |
| |
# include "openssl/camellia.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_RC2 |
| |
# include "openssl/rc2.h" |
| |
# endif |
| |
# ifndef OPENSSL_NO_IDEA |
| |
# include "openssl/idea.h" |
| |
# endif |
| |
# endif |
| |
|
| # include "sqlite3.h" |
# include "sqlite3.h" |
| # include "sigsegv.h" |
|
| |
# ifndef BROKEN_SIGSEGV |
| |
# include "sigsegv.h" |
| |
# endif |
| |
|
| # ifdef OS2 |
# ifdef OS2 |
| // Bug de libsigsegv |
// Bug de libsigsegv |
| # undef HAVE_STACK_OVERFLOW_RECOVERY |
# undef HAVE_STACK_OVERFLOW_RECOVERY |
| # endif |
# endif |
| |
|
| # define HAVE_INLINE |
|
| # define GSL_RANGE_CHECK_OFF |
# define GSL_RANGE_CHECK_OFF |
| # include "gsl/gsl_cdf.h" |
# include "gsl/gsl_cdf.h" |
| # include "gsl/gsl_cblas.h" |
# include "gsl/gsl_cblas.h" |
|
Line 211
|
Line 269
|
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| # ifndef UNIX_PATH_MAX |
# ifndef UNIX_PATH_MAX |
| struct sockaddr_un sizecheck; |
# pragma GCC diagnostic push |
| |
# pragma GCC diagnostic ignored "-Wunused-variable" |
| |
static struct sockaddr_un sizecheck; |
| # define UNIX_PATH_MAX sizeof(sizecheck.sun_path) |
# define UNIX_PATH_MAX sizeof(sizecheck.sun_path) |
| |
# pragma GCC diagnostic pop |
| # endif |
# endif |
| #endif |
#endif |
| |
|
|
Line 224
|
Line 285
|
| # define __STATIC_MUTEX_INITIALIZATION__ |
# define __STATIC_MUTEX_INITIALIZATION__ |
| #endif |
#endif |
| |
|
| |
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| Bugs spécifiques |
Bugs spécifiques |
|
Line 266 enum signaux_rpl
|
Line 328 enum signaux_rpl
|
| rpl_sighup, |
rpl_sighup, |
| rpl_sigtstp, |
rpl_sigtstp, |
| rpl_sigexcept, |
rpl_sigexcept, |
| rpl_sigmax |
rpl_sigmax, |
| |
rpl_siguser // Base des signaux à la discrétion de l'utilisateur |
| }; |
}; |
| |
|
| #define LONGUEUR_QUEUE_SIGNAUX 1024 |
#define LONGUEUR_QUEUE_SIGNAUX 1024 |
|
Line 278 enum signaux_rpl
|
Line 341 enum signaux_rpl
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| typedef struct queue_signaux |
typedef struct queue_signaux |
| { |
{ |
| # ifndef IPCS_SYSV |
|
| # ifndef SEMAPHORES_NOMMES |
|
| sem_t semaphore; |
|
| sem_t signalisation; |
|
| # endif |
|
| # else |
|
| sem_t semaphore; |
|
| sem_t signalisation; |
|
| # endif |
|
| |
|
| volatile int pointeur_lecture; |
volatile int pointeur_lecture; |
| volatile int pointeur_ecriture; |
volatile int pointeur_ecriture; |
| pthread_t thread_signaux; |
|
| volatile logical1 requete_arret; |
volatile logical1 requete_arret; |
| |
|
| |
pthread_t thread_signaux; |
| |
pid_t controle; |
| |
|
| volatile struct |
volatile struct |
| { |
{ |
| pid_t pid; |
pid_t pid; |
| enum signaux_rpl signal; |
enum signaux_rpl signal; |
| } queue[LONGUEUR_QUEUE_SIGNAUX]; |
} queue[LONGUEUR_QUEUE_SIGNAUX]; |
| |
|
| |
# ifdef OS2 |
| |
sem_t semaphore; |
| |
sem_t signalisation; |
| |
sem_t arret_signalisation; |
| |
# endif |
| } struct_queue_signaux; |
} struct_queue_signaux; |
| |
|
| __EXTERN__ struct_queue_signaux *s_queue_signaux; |
__EXTERN__ struct_queue_signaux *s_queue_signaux; |
| __EXTERN__ int f_queue_signaux; |
__EXTERN__ int f_queue_signaux; |
| |
|
| # ifdef SEMAPHORES_NOMMES |
# ifndef OS2 |
| __EXTERN__ sem_t *semaphore_queue_signaux; |
__EXTERN__ sem_t *semaphore_queue_signaux; |
| __EXTERN__ sem_t *semaphore_signalisation; |
__EXTERN__ sem_t *semaphore_signalisation; |
| |
__EXTERN__ sem_t *semaphore_arret_signalisation; |
| # endif |
# endif |
| #endif |
#endif |
| |
|
| #ifdef OS2 |
|
| # define readline(s) readline_wrapper(s) |
|
| unsigned char *readline_wrapper(unsigned char *s); |
|
| #endif |
|
| |
|
| #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV) |
#if ! defined(UNION_SEMUN) && defined(IPCS_SYSV) |
| union semun |
union semun |
| { |
{ |
|
Line 332 union semun
|
Line 389 union semun
|
| # define SIGSTKSZ 65536 |
# define SIGSTKSZ 65536 |
| #endif |
#endif |
| |
|
| |
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| SÉMAPHORES |
SÉMAPHORES |
|
Line 339 union semun
|
Line 397 union semun
|
| */ |
*/ |
| |
|
| #ifdef IPCS_SYSV |
#ifdef IPCS_SYSV |
| |
# ifdef DEBUG_SEMAPHORES |
| |
# define sem_init(a, b, c) ({ \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"initialization at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_init_SysV(a, b, c); }) |
| |
# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"waiting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) i\ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_wait_SysV(a); }) |
| |
# define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"trywaiting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) i\ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_trywait_SysV(a); }) |
| |
# define sem_post(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"posting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_post_SysV(a); }) |
| |
# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"destroying at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
if (value == 0) BUG(1, uprintf("Value %d\n", value)); \ |
| |
sem_destroy_SysV(a); }) |
| |
# else |
| |
# define sem_destroy(a) sem_destroy_SysV(a) |
| |
# define sem_wait(a) sem_wait_SysV(a) |
| |
# define sem_post(a) sem_post_SysV(a) |
| |
# endif |
| |
|
| # define sem_init(a, b, c) sem_init_SysV(a, b, c) |
# define sem_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_init(a, b, c) ({ \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"initialization at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, c), fflush(stdout); \ |
| |
sem_init(a, b, c); }) |
| |
# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"waiting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_wait(a); }) |
| |
# define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"trywaiting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_trywait(a); }) |
| |
# define sem_post(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"posting at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
sem_post(a); }) |
| |
# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \ |
| |
uprintf("[%d-%llu] Semaphore %s (%p) "\ |
| |
"destroying at %s() " \ |
| |
"line #%d <%d>\n", (int) getpid(), (unsigned long long) \ |
| |
pthread_self(), \ |
| |
#a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \ |
| |
if (value == 0) BUG(1, uprintf("Value %d\n", value)); \ |
| |
sem_destroy(a); }) |
| |
# endif |
| #endif |
#endif |
| |
|
| |
|
|
Line 419 union semun
|
Line 556 union semun
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| # ifdef SEMAPHORES_NOMMES |
# ifdef SEMAPHORES_NOMMES |
| # define LONGUEUR_NOM_SEMAPHORE 64 |
# define LONGUEUR_NOM_SEMAPHORE 64 |
| # endif |
|
| |
|
| # ifdef SEMAPHORES_NOMMES |
|
| # define __PTR__ * |
# define __PTR__ * |
| # else |
# else |
| # define __PTR__ |
# define __PTR__ |
|
Line 437 union semun
|
Line 571 union semun
|
| |
|
| __EXTERN__ pid_t pid_processus_pere; |
__EXTERN__ pid_t pid_processus_pere; |
| |
|
| # ifdef SEMAPHORES_NOMMES |
__EXTERN__ pthread_mutex_t mutex_sigaction; |
| __EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__; |
__EXTERN__ pthread_mutex_t mutex_liste_threads; |
| # endif |
__EXTERN__ pthread_mutex_t mutex_liste_threads_surveillance; |
| |
__EXTERN__ pthread_mutex_t mutex_creation_variable_partagee |
| __EXTERN__ pthread_mutex_t mutex_liste_threads |
|
| __STATIC_MUTEX_INITIALIZATION__; |
|
| __EXTERN__ pthread_mutex_t mutex_gestionnaires_signaux_atomique |
|
| __STATIC_MUTEX_INITIALIZATION__; |
__STATIC_MUTEX_INITIALIZATION__; |
| __EXTERN__ pthread_mutex_t mutex_sections_critiques; |
__EXTERN__ pthread_mutex_t mutex_sections_critiques; |
| |
__EXTERN__ pthread_mutex_t mutex_liste_variables_partagees; |
| __EXTERN__ sem_t __PTR__ semaphore_gestionnaires_signaux; |
__EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__; |
| |
|
| __EXTERN__ volatile int routine_recursive; |
__EXTERN__ volatile int routine_recursive; |
| #endif |
__EXTERN__ volatile int nombre_threads_surveillance_processus; |
| |
|
| #ifdef SEMAPHORES_NOMMES |
# define SEM_FORK 0 |
| #define SEM_FORK 0 |
# define SEM_QUEUE 1 |
| #define SEM_QUEUE 1 |
# define SEM_SIGNALISATION 2 |
| #define SEM_SIGNAUX 2 |
# define SEM_ARRET_SIGNALISATION 3 |
| #define SEM_SIGNALISATION 3 |
|
| sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre); |
sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre); |
| sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre); |
sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre); |
| int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre); |
int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre); |
| int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre); |
int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre); |
| int sem_getvalue2(sem_t *semaphore, int *valeur); |
int sem_getvalue2(sem_t *semaphore, int *valeur); |
| sem_t *sem_open2(pid_t pid, int ordre); |
sem_t *sem_open2(pid_t pid, int ordre); |
| |
#endif |
| |
|
| // Le mutex est là uniquement pour pouvoir émuler le comportement |
// Le mutex est là uniquement pour pouvoir émuler le comportement |
| // de sem_getvalue() sur un système comme MacOS X qui ne possède pas |
// de sem_getvalue() sur un système comme MacOS X qui ne possède pas |
| // cette fonction. |
// cette fonction. |
| |
|
| |
#ifdef Darwin |
| #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value) |
#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value) |
| #define sem_post(semaphore) \ |
#define sem_post(semaphore) \ |
| ({ int r; pthread_mutex_lock(&mutex_sem); \ |
({ int r; pthread_mutex_lock(&mutex_sem); \ |
|
Line 493 sem_t *sem_open2(pid_t pid, int ordre);
|
Line 626 sem_t *sem_open2(pid_t pid, int ordre);
|
| stderr, __VA_ARGS__) |
stderr, __VA_ARGS__) |
| #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \ |
#define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \ |
| flux, __VA_ARGS__) |
flux, __VA_ARGS__) |
| #define uprintf(...) transliterated_fprintf(NULL, \ |
#define uprintf(...) std_fprintf(stderr, __VA_ARGS__) |
| stderr, __VA_ARGS__) |
#define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__) |
| #define ufprintf(flux, ...) transliterated_fprintf(NULL, \ |
|
| flux, __VA_ARGS__) |
|
| |
|
| #ifdef SunOS |
#ifdef SunOS |
| # define fopen(...) ({ FILE *desc; \ |
# define fopen(...) ({ FILE *desc; \ |
|
Line 518 sem_t *sem_open2(pid_t pid, int ordre);
|
Line 649 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 |
|
| // système dans le cas où l'on a atteint le nombre maximale de fichiers |
|
| // ouverts. |
|
| |
|
| #define pipe(descripteurs) \ |
|
| ({ \ |
|
| struct timespec temporisation; \ |
|
| int erreur, nombre_echecs; \ |
|
| nombre_echecs = 0; \ |
|
| do \ |
|
| { \ |
|
| if ((erreur = pipe(descripteurs)) == 0) break; \ |
|
| nombre_echecs++; \ |
|
| temporisation.tv_sec = 0; \ |
|
| temporisation.tv_nsec = ((long) 1000000000) * rand(); \ |
|
| nanosleep(&temporisation, NULL); \ |
|
| } while(nombre_echecs < 100); \ |
|
| erreur; \ |
|
| }) |
|
| |
|
| // Redéfinition de abs pour un fonctionnement en entier de type long long int |
// Redéfinition de abs pour un fonctionnement en entier de type long long int |
| |
|
| #ifdef __GNUC__ |
#ifdef __GNUC__ |
|
Line 560 sem_t *sem_open2(pid_t pid, int ordre);
|
Line 671 sem_t *sem_open2(pid_t pid, int ordre);
|
| } while(0) |
} while(0) |
| |
|
| #ifdef __GLIBC__ |
#ifdef __GLIBC__ |
| #include <execinfo.h> |
# include <execinfo.h> |
| #define __BACKTRACE |
# define __BACKTRACE |
| #define BACKTRACE(n) \ |
# define BACKTRACE(n) \ |
| do \ |
do \ |
| { \ |
{ \ |
| void *buffer[n]; \ |
void *buffer[n]; \ |
|
Line 578 sem_t *sem_open2(pid_t pid, int ordre);
|
Line 689 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 587 sem_t *sem_open2(pid_t pid, int ordre);
|
Line 698 sem_t *sem_open2(pid_t pid, int ordre);
|
| pthread_mutex_unlock(&mutex); \ |
pthread_mutex_unlock(&mutex); \ |
| } while(0) |
} while(0) |
| #else |
#else |
| #define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc") |
# define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc") |
| #endif |
#endif |
| |
|
| #ifdef __BACKTRACE |
#ifdef __BACKTRACE |
|
Line 623 void *debug_memoire_modification(void *p
|
Line 734 void *debug_memoire_modification(void *p
|
| void debug_memoire_retrait(void *ptr); |
void debug_memoire_retrait(void *ptr); |
| void debug_memoire_verification(); |
void debug_memoire_verification(); |
| |
|
| pid_t debug_fork(); |
|
| |
|
| #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s) |
|
| #define free(s) debug_memoire_retrait(s) |
#define free(s) debug_memoire_retrait(s) |
| #define realloc(s, t) debug_memoire_modification(s, t, \ |
#ifdef RPLCXX |
| __FUNCTION__, __LINE__, #t) |
# define malloc(s) debug_memoire_ajout(s, \ |
| #define fork() debug_fork() |
const_cast<const unsigned char *> \ |
| |
(reinterpret_cast<unsigned char *> \ |
| |
(const_cast<char *>(__FUNCTION__))), __LINE__, \ |
| |
const_cast<const unsigned char *> \ |
| |
(reinterpret_cast<unsigned char *> \ |
| |
(const_cast<char *>(#s)))) |
| |
# define realloc(s, t) debug_memoire_modification(s, t, \ |
| |
const_cast<const unsigned char *> \ |
| |
(reinterpret_cast<unsigned char *> \ |
| |
(const_cast<char *>(__FUNCTION__))), __LINE__, \ |
| |
const_cast<const unsigned char *> \ |
| |
(reinterpret_cast<unsigned char *> \ |
| |
(const_cast<char *>(#t)))) |
| |
#else |
| |
# define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, \ |
| |
(const unsigned char *) #s) |
| |
# define realloc(s, t) debug_memoire_modification(s, t, \ |
| |
__FUNCTION__, __LINE__, (const unsigned char *) #t) |
| |
#endif |
| |
#define fork() debug_fork(s_etat_processus) |
| #endif |
#endif |
| |
|
| #ifdef DEBUG_RETURN |
#ifdef DEBUG_RETURN |
| #define return uprintf("[%d] Return from <%s()> at line #%d " \ |
# define return uprintf("[%d] Return from <%s()> at line #%d " \ |
| "(%s [%d])\n", (int) getpid(), __FUNCTION__, \ |
"(%s [%d])\n", (int) getpid(), __FUNCTION__, \ |
| __LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return |
__LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return |
| #endif |
#endif |
| |
|
| #ifdef DEBUG_MUTEX |
#ifdef DEBUG_MUTEX |
| #define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \ |
# define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \ |
| "locking at %s() " \ |
"locking at %s() " \ |
| "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \ |
"line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \ |
| #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \ |
#mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \ |
| pthread_mutex_lock(mutex) |
pthread_mutex_lock(mutex) |
| #define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \ |
# define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \ |
| "unlocking at " \ |
"unlocking at " \ |
| "%s() line #%d\n", (int) getpid(), (unsigned long long) \ |
"%s() line #%d\n", (int) getpid(), (unsigned long long) \ |
| pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \ |
pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \ |
| fflush(stdout), \ |
fflush(stdout), \ |
| pthread_mutex_unlock(mutex) |
pthread_mutex_unlock(mutex) |
| #endif |
# define pthread_mutex_trylock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \ |
| |
"trylocking at " \ |
| #ifdef DEBUG_SEMAPHORES |
"%s() line #%d\n", (int) getpid(), (unsigned long long) \ |
| #define sem_wait(a) ({ int value; sem_getvalue(a, &value); \ |
pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \ |
| uprintf("[%d-%llu] Semaphore %s (%p) "\ |
fflush(stdout), \ |
| "waiting at %s() " \ |
pthread_mutex_trylock(mutex) |
| "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 |
| |
|
| |
|
|
Line 717 pid_t debug_fork();
|
Line 833 pid_t debug_fork();
|
| #define d_SPH "Semaphore $n 'name'" |
#define d_SPH "Semaphore $n 'name'" |
| #define d_TAB "<[ table ]>" |
#define d_TAB "<[ table ]>" |
| #define d_MTX "Mutex $n" |
#define d_MTX "Mutex $n" |
| |
#define d_REC "|[ record ]|" |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
|
Line 754 pid_t debug_fork();
|
Line 871 pid_t debug_fork();
|
| # else |
# else |
| # define __erreur_(i) i |
# define __erreur_(i) i |
| # endif |
# endif |
| # define __erreur(i) ({ if (strstr(__FUNCTION__, "recherche_variable") \ |
# define __erreur(i) ({ int ios; ios = errno; \ |
| == NULL) ufprintf(stderr, \ |
if (strstr(__FUNCTION__, "recherche_variable") \ |
| "ERROR %d AT %s() FROM %s LINE %d\n", \ |
== NULL) { if(ios != 0) \ |
| i, __FUNCTION__, __FILE__, __LINE__); i; }) |
ufprintf(stderr, "LAST ERROR: %s\n", strerror(ios)); \ |
| |
ufprintf(stderr, "ERROR %d AT %s() FROM %s LINE %d\n", \ |
| |
i, __FUNCTION__, __FILE__, __LINE__); BACKTRACE(16); } i; }) |
| # endif |
# endif |
| #else |
#else |
| # define __erreur(i) i |
# define __erreur(i) i |
| # define __erreur_(i) i |
# define __erreur_(i) i |
| #endif |
#endif |
| |
|
| |
#ifdef DEBUG_FICHIERS |
| |
# define open(a, ...) \ |
| |
({ ufprintf(stderr, "[%d] OPEN %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); open(a, __VA_ARGS__); }) |
| |
# define pipe(a) \ |
| |
({ ufprintf(stderr, "[%d] PIPE %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); pipe(a); }) |
| |
# define shm_open(a, ...) \ |
| |
({ ufprintf(stderr, "[%d] SHM_OPEN %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); shm_open(a, __VA_ARGS__); }) |
| |
# define shm_unlink(a) \ |
| |
({ ufprintf(stderr, "[%d] SHM_UNLINK %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); shm_unlink(a); }) |
| |
# define sem_open(a, ...) \ |
| |
({ ufprintf(stderr, "[%d] SEM_OPEN %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); sem_open(a, __VA_ARGS__); }) |
| |
# define sem_unlink(a) \ |
| |
({ ufprintf(stderr, "[%d] SEM_UNLINK %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); sem_unlink(a); }) |
| |
# define close(a) \ |
| |
({ ufprintf(stderr, "[%d] CLOSE %s AT %s() FROM %s LINE %d\n", \ |
| |
getpid(), a, \ |
| |
__FUNCTION__, __FILE__, __LINE__); close(a); }) |
| |
#endif |
| |
|
| // -1 : erreur provoquée par une bibliothèque externe |
// -1 : erreur provoquée par une bibliothèque externe |
| #ifndef RPLARGS |
#ifndef RPLARGS |
|
Line 926 pid_t debug_fork();
|
Line 1075 pid_t debug_fork();
|
| # define d_ex_mutex_acquis_autre_thread __erreur(86) |
# define d_ex_mutex_acquis_autre_thread __erreur(86) |
| # define d_ex_expression_reguliere __erreur(87) |
# define d_ex_expression_reguliere __erreur(87) |
| # define d_ex_instruction_indisponible __erreur(88) |
# define d_ex_instruction_indisponible __erreur(88) |
| |
# define d_ex_chiffrement __erreur(89) |
| |
# define d_ex_chiffrement_indisponible __erreur(90) |
| |
# define d_ex_longueur_clef_chiffrement __erreur(91) |
| |
# define d_ex_taille_message __erreur(92) |
| |
# define d_ex_type_externe_dup __erreur(93) |
| |
# define d_ex_type_externe_drop __erreur(94) |
| |
# define d_ex_simplification __erreur(95) |
| #endif |
#endif |
| |
|
| |
|
|
Line 954 pid_t debug_fork();
|
Line 1110 pid_t debug_fork();
|
| #define BIN __RPL_BIN |
#define BIN __RPL_BIN |
| #define CHN __RPL_CHN |
#define CHN __RPL_CHN |
| #define CPL __RPL_CPL |
#define CPL __RPL_CPL |
| |
#define EXT __RPL_EXT |
| #define FCH __RPL_FCH |
#define FCH __RPL_FCH |
| #define FCT __RPL_FCT |
#define FCT __RPL_FCT |
| #define INT __RPL_INT |
#define INT __RPL_INT |
|
Line 965 pid_t debug_fork();
|
Line 1122 pid_t debug_fork();
|
| #define NOM __RPL_NOM |
#define NOM __RPL_NOM |
| #define NON __RPL_NON |
#define NON __RPL_NON |
| #define PRC __RPL_PRC |
#define PRC __RPL_PRC |
| |
#define REC __RPL_REC |
| #define REL __RPL_REL |
#define REL __RPL_REL |
| #define RPN __RPL_RPN |
#define RPN __RPL_RPN |
| #define SCK __RPL_SCK |
#define SCK __RPL_SCK |
|
Line 976 pid_t debug_fork();
|
Line 1134 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_rplcas_commandes { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE, |
| |
RPLCAS_SIMPLIFICATION }; |
| |
|
| enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST, |
enum t_type { ADR = 0, ALG, BIN, CHN, CPL, EXT, FCH, FCT, INT, LST, |
| MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK, |
MCX, MIN, MRL, MTX, NOM, NON, PRC, REC, REL, RPN, SCK, |
| SLB, SPH, SQL, TBL, VCX, VIN, VRL }; |
SLB, SPH, SQL, TBL, VCX, VIN, VRL }; |
| |
|
| /* |
/* |
| ADR : adresse sur 32 bits (au moins) non signés (unsigned long) |
ADR : adresse sur 64 bits signés. |
| Adresse d'une définition à interpréter. |
Adresse d'une définition à interpréter. |
| |
|
| ALG : expression algébrique (struct_liste_chainee *) |
ALG : expression algébrique (struct_liste_chainee *) |
|
Line 995 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
Line 1154 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
| Sans objet. |
Sans objet. |
| Type C/Fortran : unsigned integer8 |
Type C/Fortran : unsigned integer8 |
| |
|
| CHN : chaine de caracteres (character*(*), unsigned char *) |
CHN : chaine de caracteres (unsigned char *) |
| Sans objet. |
Sans objet. |
| |
|
| CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *) |
CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *) |
| Sans objet. |
Sans objet. |
| Type C/Fortran : complex16 |
Type C/Fortran : complex16 |
| |
|
| |
EXT : type géré dans une bibliothèque externe. |
| |
|
| FCH : descripteur de fichier (struct_fichier *). |
FCH : descripteur de fichier (struct_fichier *). |
| |
|
| FCT : déclaration d'une fonction et de son nombre d'arguments |
FCT : déclaration d'une fonction et de son nombre d'arguments |
|
Line 1036 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
Line 1197 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
| PRC : processus (struct_processus_fils *) |
PRC : processus (struct_processus_fils *) |
| Sans objet. |
Sans objet. |
| |
|
| |
REC : enregistrement (struct_record *) |
| |
|
| REL : reel sur 64 bits (real*8, real8 *) |
REL : reel sur 64 bits (real*8, real8 *) |
| Sans objet. |
Sans objet. |
| |
|
|
Line 1067 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
Line 1230 enum t_type { ADR = 0, ALG, BIN, CHN, C
|
| typedef struct objet |
typedef struct objet |
| { |
{ |
| enum t_type type; |
enum t_type type; |
| |
integer8 extension_type; |
| |
void *descripteur_bibliotheque; |
| |
|
| volatile long nombre_occurrences; |
volatile long nombre_occurrences; |
| |
|
|
Line 1085 typedef struct objet
|
Line 1250 typedef struct objet
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| typedef struct fichier |
typedef struct fichier |
| { |
{ |
| unsigned long descripteur; |
int descripteur; |
| |
|
| unsigned char acces; /* S/D/I */ |
unsigned char acces; /* S/D/I */ |
| unsigned char binaire; /* Y/N/F */ |
unsigned char binaire; /* Y/N/F */ |
|
Line 1178 typedef struct bibliotheque
|
Line 1343 typedef struct bibliotheque
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| typedef struct descripteur_fichier |
typedef struct descripteur_fichier |
| { |
{ |
| unsigned long identifiant; |
int identifiant; |
| |
|
| unsigned char effacement; |
unsigned char effacement; |
| unsigned char type; // C (file *) ou S (sqlite *) |
unsigned char type; // C (file *) ou S (sqlite *) |
|
Line 1224 typedef struct connecteur_sql
|
Line 1389 typedef struct connecteur_sql
|
| # ifdef POSTGRESQL_SUPPORT |
# ifdef POSTGRESQL_SUPPORT |
| PGconn *postgresql; |
PGconn *postgresql; |
| # endif |
# endif |
| |
sqlite3 *sqlite; |
| } descripteur; |
} descripteur; |
| } struct_connecteur_sql; |
} struct_connecteur_sql; |
| #endif |
#endif |
|
Line 1237 typedef struct connecteur_sql
|
Line 1403 typedef struct connecteur_sql
|
| "POSTGRESQL") == 0) \ |
"POSTGRESQL") == 0) \ |
| postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \ |
postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \ |
| .descripteur); \ |
.descripteur); \ |
| |
else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, \ |
| |
"SQLITE") == 0) \ |
| |
sqlite3_close((*((struct_connecteur_sql *) (*s_objet).objet)) \ |
| |
.descripteur.sqlite); \ |
| else \ |
else \ |
| BUG(1, uprintf("SQL type '%s' not allowed!", \ |
BUG(1, uprintf("SQL type '%s' not allowed!", \ |
| (*((struct_connecteur_sql *) (*s_objet).objet)).type)); |
(*((struct_connecteur_sql *) (*s_objet).objet)).type)); |
|
Line 1248 typedef struct connecteur_sql
|
Line 1418 typedef struct connecteur_sql
|
| */ |
*/ |
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| |
|
| |
# define d_BIND_TO_DEVICE 0 |
| |
# define d_BROADCAST 1 |
| |
# define d_DONT_ROUTE 2 |
| |
# define d_KEEP_ALIVE 3 |
| |
# define d_PRIORITY 4 |
| |
# define d_RECEIVE_BUFFER 5 |
| |
# define d_FORCE_RECEIVE_BUFFER 6 |
| |
# define d_SEND_BUFFER 7 |
| |
# define d_FORCE_SEND_BUFFER 8 |
| |
# define d_RECEIVING_TIMEOUT 9 |
| |
# define d_SENDING_TIMEOUT 10 |
| |
# define d_REUSE_ADDRESS 11 |
| |
|
| typedef struct socket |
typedef struct socket |
| { |
{ |
| int domaine; |
int domaine; |
|
Line 1266 typedef struct socket
|
Line 1450 typedef struct socket
|
| unsigned char protection; |
unsigned char protection; |
| unsigned char type[19 + 1]; |
unsigned char type[19 + 1]; |
| |
|
| |
integer8 options; |
| |
int priorite; |
| |
int buffer_reception; |
| |
int buffer_emission; |
| |
int timeout_emission; |
| |
int timeout_reception; |
| |
|
| struct_objet *format; |
struct_objet *format; |
| } struct_socket; |
} struct_socket; |
| #endif |
#endif |
|
Line 1412 typedef struct descripteur_thread
|
Line 1603 typedef struct descripteur_thread
|
| int pipe_injections[2]; |
int pipe_injections[2]; |
| int pipe_nombre_injections[2]; |
int pipe_nombre_injections[2]; |
| int pipe_interruptions[2]; |
int pipe_interruptions[2]; |
| int pipe_nombre_objets_attente[2]; |
// pipe_nombre_elements_attente == 0 => initialisation ou terminaison |
| int pipe_nombre_interruptions_attente[2]; |
// pipe_nombre_elements_attente == 1 => objet en attente |
| |
// pipe_nombre_elements_attente == 2 => interruption en attente |
| |
int pipe_nombre_elements_attente[2]; |
| int pipe_acquittement[2]; |
int pipe_acquittement[2]; |
| |
|
| volatile integer8 nombre_objets_dans_pipe; |
volatile integer8 nombre_objets_dans_pipe; |
|
Line 1443 typedef struct liste_pile_systeme
|
Line 1636 typedef struct liste_pile_systeme
|
| { |
{ |
| struct liste_pile_systeme *suivant; |
struct liste_pile_systeme *suivant; |
| |
|
| struct_liste_chainee *pointeur_objet_retour; |
|
| |
|
| struct_objet *indice_boucle; |
struct_objet *indice_boucle; |
| struct_objet *limite_indice_boucle; |
struct_objet *limite_indice_boucle; |
| struct_objet *objet_de_test; |
struct_objet *objet_de_test; |
|
Line 1453 typedef struct liste_pile_systeme
|
Line 1644 typedef struct liste_pile_systeme
|
| logical1 creation_variables_statiques; |
logical1 creation_variables_statiques; |
| logical1 creation_variables_partagees; |
logical1 creation_variables_partagees; |
| logical1 evaluation_expression; |
logical1 evaluation_expression; |
| |
logical1 debug_programme; |
| |
|
| unsigned char clause; |
unsigned char clause; |
| |
|
|
Line 1498 typedef struct liste_pile_systeme
|
Line 1690 typedef struct liste_pile_systeme
|
| A FORALL : NEXT termine une boucle sur un objet. |
A FORALL : NEXT termine une boucle sur un objet. |
| */ |
*/ |
| |
|
| unsigned long adresse_retour; |
integer8 adresse_retour; |
| unsigned long niveau_courant; |
integer8 niveau_courant; |
| struct_objet *pointeur_adresse_retour; |
struct_liste_chainee *pointeur_objet_retour; |
| } struct_liste_pile_systeme; |
} struct_liste_pile_systeme; |
| #endif |
#endif |
| |
|
|
Line 1514 typedef struct liste_pile_systeme
|
Line 1706 typedef struct liste_pile_systeme
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| typedef union position_variable |
typedef union position_variable |
| { |
{ |
| unsigned long adresse; |
integer8 adresse; |
| struct_objet *pointeur; |
struct_objet *pointeur; |
| } union_position_variable; |
} union_position_variable; |
| |
|
|
Line 1523 typedef struct variable
|
Line 1715 typedef struct variable
|
| unsigned char *nom; |
unsigned char *nom; |
| unsigned char origine; // P(rogramme) ou E(valuation) |
unsigned char origine; // P(rogramme) ou E(valuation) |
| |
|
| unsigned long niveau; |
integer8 niveau; |
| |
|
| union_position_variable variable_statique; |
union_position_variable variable_statique; |
| union_position_variable variable_partagee; |
union_position_variable variable_partagee; |
|
Line 1548 typedef struct variable_partage
|
Line 1740 typedef struct variable_partage
|
| unsigned char *nom; |
unsigned char *nom; |
| unsigned char origine; |
unsigned char origine; |
| |
|
| unsigned long niveau; |
integer8 niveau; |
| |
|
| union_position_variable variable_partagee; |
union_position_variable variable_partagee; |
| |
|
| struct_objet *objet; |
struct_objet *objet; |
| } struct_variable_partagee; |
|
| |
|
| typedef struct table_variables_partagees |
|
| { |
|
| pthread_mutex_t mutex; |
|
| |
|
| volatile struct_variable_partagee *table; |
pthread_mutex_t mutex; |
| |
} struct_variable_partagee; |
| volatile unsigned long nombre_variables; |
|
| volatile unsigned long nombre_variables_allouees; |
|
| |
|
| unsigned long position_variable; |
|
| } struct_table_variables_partagees; |
|
| |
|
| #endif |
#endif |
| |
|
|
Line 1585 typedef struct variable_statique
|
Line 1767 typedef struct variable_statique
|
| // Position de création de la variable statique dans le programme ou dans |
// Position de création de la variable statique dans le programme ou dans |
| // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression. |
// l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression. |
| |
|
| unsigned long niveau; |
integer8 niveau; |
| |
|
| union_position_variable variable_statique; |
union_position_variable variable_statique; |
| |
|
|
Line 1602 typedef struct variable_statique
|
Line 1784 typedef struct variable_statique
|
| |
|
| typedef struct vecteur |
typedef struct vecteur |
| { |
{ |
| unsigned long taille; |
integer8 taille; |
| |
|
| unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ |
unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ |
| |
|
|
Line 1618 typedef struct vecteur
|
Line 1800 typedef struct vecteur
|
| |
|
| typedef struct matrice |
typedef struct matrice |
| { |
{ |
| unsigned long nombre_lignes; |
integer8 nombre_lignes; |
| unsigned long nombre_colonnes; |
integer8 nombre_colonnes; |
| |
|
| unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ |
unsigned char type; /* C (complex*16), R (real*8), I (integer*8) */ |
| |
|
|
Line 1635 typedef struct matrice
|
Line 1817 typedef struct matrice
|
| |
|
| typedef struct tableau |
typedef struct tableau |
| { |
{ |
| unsigned long nombre_elements; |
integer8 nombre_elements; |
| |
|
| struct_objet **elements; |
struct_objet **elements; |
| } struct_tableau; |
} struct_tableau; |
|
Line 1643 typedef struct tableau
|
Line 1825 typedef struct tableau
|
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| |
Structure enregistrement |
| |
-------------------------------------------------------------------------------- |
| |
*/ |
| |
|
| |
typedef struct record |
| |
{ |
| |
struct_objet *noms; |
| |
struct_objet *donnees; |
| |
} struct_record; |
| |
|
| |
|
| |
/* |
| |
-------------------------------------------------------------------------------- |
| Structure arbre |
Structure arbre |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| typedef struct arbre |
typedef struct arbre |
| { |
{ |
| struct_objet *objet; |
struct_liste_chainee *feuille; |
| |
|
| unsigned long nombre_feuilles; |
integer8 nombre_branches; |
| struct arbre **feuilles; |
struct arbre **branches; |
| } struct_arbre; |
} struct_arbre; |
| |
|
| |
|
|
Line 1667 typedef struct instruction_externe
|
Line 1862 typedef struct instruction_externe
|
| unsigned char *nom; |
unsigned char *nom; |
| unsigned char *nom_bibliotheque; |
unsigned char *nom_bibliotheque; |
| void *descripteur_bibliotheque; |
void *descripteur_bibliotheque; |
| |
integer8 position_fleche; |
| } struct_instruction_externe; |
} struct_instruction_externe; |
| |
|
| |
|
|
Line 1708 typedef struct rpl_arguments
|
Line 1904 typedef struct rpl_arguments
|
| unsigned char test_instruction; |
unsigned char test_instruction; |
| |
|
| integer8 nombre_arguments; |
integer8 nombre_arguments; |
| // Nombre d'arguments de la fonction, positif ou nul. |
// Nombre d'arguments de la fonction |
| |
// 0 : instruction infixe |
| |
// positif : nombre d'arguments (notation algébrique possible) |
| |
// -1 : notation algrébrique non autorisée |
| |
|
| void *s_etat_processus; |
void *s_etat_processus; |
| } struct_rpl_arguments; |
} struct_rpl_arguments; |
|
Line 1750 typedef struct arbre_variables
|
Line 1949 typedef struct arbre_variables
|
| struct liste_variables_statiques *feuille_statique; |
struct liste_variables_statiques *feuille_statique; |
| } struct_arbre_variables; |
} struct_arbre_variables; |
| |
|
| |
typedef struct arbre_variables_partagees |
| |
{ |
| |
unsigned int noeuds_utilises; |
| |
// Nombre de noeuds utilisés dans le |
| |
// tableau **noeuds |
| |
signed int indice_tableau_pere; |
| |
// Position de la structure dans le |
| |
// tableau **noeuds du père |
| |
|
| |
struct arbre_variables_partagees *noeud_pere; |
| |
struct arbre_variables_partagees **noeuds; |
| |
|
| |
struct liste_variables_partagees *feuille; |
| |
|
| |
pthread_mutex_t mutex_feuille; |
| |
} struct_arbre_variables_partagees; |
| |
|
| |
#define INITIALISATION_MUTEX(mutex) \ |
| |
do { \ |
| |
pthread_mutexattr_t attributs_mutex; \ |
| |
pthread_mutexattr_init(&attributs_mutex); \ |
| |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); \ |
| |
pthread_mutex_init(&(mutex), &attributs_mutex); \ |
| |
pthread_mutexattr_destroy(&attributs_mutex); \ |
| |
} while(0) |
| |
|
| typedef struct tableau_variables |
typedef struct tableau_variables |
| { |
{ |
| unsigned char origine; |
unsigned char origine; |
| unsigned char *nom; // pointeur sur la struct_variable |
unsigned char *nom; // pointeur sur la struct_variable |
| // réelle et non copie de la chaîne |
// réelle et non copie de la chaîne |
| unsigned long niveau; |
integer8 niveau; |
| |
|
| struct_objet *objet; // pointeur sur l'objet et non copie |
struct_objet *objet; // pointeur sur l'objet et non copie |
| // de l'objet. |
// de l'objet. |
| |
|
| logical1 variable_verrouillee; |
logical1 variable_verrouillee; |
| logical1 variable_masquee; |
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; |
|
Line 1793 typedef struct liste_variables_statiques
|
Line 2019 typedef struct liste_variables_statiques
|
| struct_arbre_variables *feuille; |
struct_arbre_variables *feuille; |
| struct_variable_statique *variable; |
struct_variable_statique *variable; |
| } struct_liste_variables_statiques; |
} struct_liste_variables_statiques; |
| |
|
| |
typedef struct liste_variables_partagees |
| |
{ |
| |
struct liste_variables_partagees *suivant; |
| |
struct liste_variables_partagees *precedent; |
| |
struct liste_variables_partagees *reference; |
| |
struct_arbre_variables_partagees *feuille; |
| |
struct_variable_partagee *variable; |
| |
pthread_t tid; |
| |
pid_t pid; |
| |
} struct_liste_variables_partagees; |
| #endif |
#endif |
| |
|
| |
|
| |
/* |
| |
-------------------------------------------------------------------------------- |
| |
Structure fonction |
| |
-------------------------------------------------------------------------------- |
| |
*/ |
| |
|
| |
#ifndef RPLARGS |
| |
typedef struct fonction |
| |
{ |
| |
unsigned char *nom_fonction; |
| |
integer8 nombre_arguments; |
| |
|
| |
void (*fonction)(struct processus *); |
| |
|
| |
volatile struct_liste_chainee *prediction_saut; |
| |
volatile logical1 prediction_execution; |
| |
} struct_fonction; |
| |
#endif |
| |
|
| |
|
| |
/* |
| |
-------------------------------------------------------------------------------- |
| |
Structure buffer |
| |
-------------------------------------------------------------------------------- |
| |
*/ |
| |
|
| |
typedef struct buffer |
| |
{ |
| |
unsigned char *buffer; |
| |
|
| |
size_t longueur_requise; |
| |
int classe; |
| |
} struct_buffer; |
| |
|
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Structure processus |
Structure processus |
|
Line 1823 typedef struct processus
|
Line 2096 typedef struct processus
|
| unsigned char evaluation_forcee; /*Y/N*/ |
unsigned char evaluation_forcee; /*Y/N*/ |
| unsigned char instruction_valide; /*Y/N*/ |
unsigned char instruction_valide; /*Y/N*/ |
| unsigned char instruction_intrinseque; /*Y/I/N*/ |
unsigned char instruction_intrinseque; /*Y/I/N*/ |
| |
unsigned char instruction_sensible; /*Y/N*/ |
| unsigned char test_instruction; /*Y/N*/ |
unsigned char test_instruction; /*Y/N*/ |
| unsigned char affichage_arguments; /*Y/N*/ |
unsigned char affichage_arguments; /*Y/N*/ |
| unsigned char constante_symbolique; /*Y/N*/ |
unsigned char constante_symbolique; /*Y/N*/ |
|
Line 1833 typedef struct processus
|
Line 2107 typedef struct processus
|
| unsigned char traitement_cycle_exit; /*N/E/C*/ |
unsigned char traitement_cycle_exit; /*N/E/C*/ |
| unsigned char recherche_type; /*Y/N*/ |
unsigned char recherche_type; /*Y/N*/ |
| |
|
| unsigned long position_courante; |
integer8 position_courante; |
| unsigned long longueur_definitions_chainees; |
integer8 longueur_definitions_chainees; |
| |
|
| /* Pointeurs sur les instructions */ |
/* Pointeurs sur les instructions */ |
| |
|
|
Line 1851 typedef struct processus
|
Line 2125 typedef struct processus
|
| struct_liste_chainee *l_base_pile; |
struct_liste_chainee *l_base_pile; |
| struct_liste_chainee *l_base_pile_last; |
struct_liste_chainee *l_base_pile_last; |
| |
|
| unsigned long hauteur_pile_operationnelle; |
integer8 hauteur_pile_operationnelle; |
| |
|
| /* Piles systemes */ |
/* Piles systemes */ |
| |
|
| struct_liste_pile_systeme *l_base_pile_systeme; |
struct_liste_pile_systeme *l_base_pile_systeme; |
| |
|
| unsigned long hauteur_pile_systeme; |
integer8 hauteur_pile_systeme; |
| |
|
| /* Gestion des processus */ |
/* Gestion des processus */ |
| |
|
|
Line 1871 typedef struct processus
|
Line 2145 typedef struct processus
|
| int pipe_injections; |
int pipe_injections; |
| int pipe_nombre_injections; |
int pipe_nombre_injections; |
| int pipe_interruptions; |
int pipe_interruptions; |
| int pipe_nombre_objets_attente; |
int pipe_nombre_elements_attente; |
| int pipe_nombre_interruptions_attente; |
|
| int nombre_objets_envoyes_non_lus; |
int nombre_objets_envoyes_non_lus; |
| int nombre_objets_injectes; |
int nombre_objets_injectes; |
| |
|
|
Line 1882 typedef struct processus
|
Line 2155 typedef struct processus
|
| logical1 presence_fusible; |
logical1 presence_fusible; |
| pthread_t thread_fusible; |
pthread_t thread_fusible; |
| pthread_t thread_surveille_par_fusible; |
pthread_t thread_surveille_par_fusible; |
| |
pthread_t thread_signaux; |
| |
int pipe_signaux[2]; |
| |
|
| volatile int pointeur_signal_ecriture; |
volatile int pointeur_signal_ecriture; |
| volatile int pointeur_signal_lecture; |
volatile int pointeur_signal_lecture; |
|
Line 1910 typedef struct processus
|
Line 2185 typedef struct processus
|
| struct_liste_variables *l_liste_variables_par_niveau; |
struct_liste_variables *l_liste_variables_par_niveau; |
| struct_liste_variables_statiques |
struct_liste_variables_statiques |
| *l_liste_variables_statiques; |
*l_liste_variables_statiques; |
| struct_table_variables_partagees |
|
| *s_liste_variables_partagees; |
struct_arbre_variables_partagees |
| |
**s_arbre_variables_partagees; |
| |
struct_liste_variables_partagees |
| |
**l_liste_variables_partagees; |
| |
|
| logical1 niveau_supprime; |
logical1 niveau_supprime; |
| |
|
| struct_variable *pointeur_variable_courante; |
struct_variable *pointeur_variable_courante; |
| struct_liste_variables *pointeur_feuille_courante; |
struct_liste_variables *pointeur_feuille_courante; |
| struct_variable_statique *pointeur_variable_statique_courante; |
struct_variable_statique *pointeur_variable_statique_courante; |
| |
struct_variable_partagee *pointeur_variable_partagee_courante; |
| |
|
| int *pointeurs_caracteres_variables; |
int *pointeurs_caracteres_variables; |
| int nombre_caracteres_variables; |
int nombre_caracteres_variables; |
| |
|
| unsigned long niveau_courant; |
integer8 niveau_courant; |
| unsigned long niveau_initial; |
integer8 niveau_initial; |
| |
|
| logical1 creation_variables_statiques; |
logical1 creation_variables_statiques; |
| logical1 creation_variables_partagees; |
logical1 creation_variables_partagees; |
|
Line 1945 typedef struct processus
|
Line 2224 typedef struct processus
|
| |
|
| struct_liste_chainee *s_bibliotheques; |
struct_liste_chainee *s_bibliotheques; |
| struct_instruction_externe *s_instructions_externes; |
struct_instruction_externe *s_instructions_externes; |
| unsigned long nombre_instructions_externes; |
integer8 nombre_instructions_externes; |
| |
|
| /* Fichier d'impression */ |
/* Fichier d'impression */ |
| |
|
|
Line 2095 typedef struct processus
|
Line 2374 typedef struct processus
|
| /* Traitement des exceptions */ |
/* Traitement des exceptions */ |
| |
|
| logical1 arret_si_exception; |
logical1 arret_si_exception; |
| unsigned int exception; |
int exception; |
| unsigned int derniere_exception; |
int derniere_exception; |
| unsigned int exception_processus_fils; |
int exception_processus_fils; |
| |
|
| /* Traitement des erreurs */ |
/* Traitement des erreurs */ |
| |
|
| unsigned int erreur_compilation; |
int erreur_compilation; |
| unsigned int erreur_execution; |
volatile int erreur_execution; |
| unsigned int erreur_systeme; |
volatile int erreur_systeme; |
| |
|
| struct_objet *s_objet_errone; |
struct_objet *s_objet_errone; |
| struct_objet *s_objet_erreur; |
struct_objet *s_objet_erreur; |
| |
|
| logical1 erreur_scrutation; |
logical1 erreur_scrutation; |
| |
|
| volatile unsigned int erreur_systeme_processus_fils; |
volatile int erreur_systeme_processus_fils; |
| unsigned int erreur_execution_processus_fils; |
int erreur_execution_processus_fils; |
| |
|
| pid_t pid_erreur_processus_fils; |
pid_t pid_erreur_processus_fils; |
| |
|
|
Line 2119 typedef struct processus
|
Line 2398 typedef struct processus
|
| |
|
| integer8 derniere_erreur_fonction_externe; |
integer8 derniere_erreur_fonction_externe; |
| |
|
| unsigned int derniere_erreur_systeme; |
int derniere_erreur_systeme; |
| unsigned int derniere_erreur_execution; |
int derniere_erreur_execution; |
| unsigned int derniere_erreur_evaluation; |
int derniere_erreur_evaluation; |
| |
|
| unsigned char *instruction_derniere_erreur; |
unsigned char *instruction_derniere_erreur; |
| |
|
| unsigned long niveau_derniere_erreur; |
integer8 niveau_derniere_erreur; |
| |
|
| logical1 core; |
logical1 core; |
| logical1 invalidation_message_erreur; |
logical1 invalidation_message_erreur; |
|
Line 2133 typedef struct processus
|
Line 2412 typedef struct processus
|
| /* Debug */ |
/* Debug */ |
| |
|
| logical1 debug; |
logical1 debug; |
| integer8 type_debug; |
logical8 type_debug; |
| logical1 debug_programme; |
logical1 debug_programme; |
| logical1 execution_pas_suivant; |
logical1 execution_pas_suivant; |
| logical1 traitement_instruction_halt; |
logical1 traitement_instruction_halt; |
|
Line 2208 typedef struct processus
|
Line 2487 typedef struct processus
|
| unsigned char retour_routine_evaluation; |
unsigned char retour_routine_evaluation; |
| unsigned char *localisation; |
unsigned char *localisation; |
| |
|
| unsigned long niveau_recursivite; |
integer8 niveau_recursivite; |
| |
|
| pid_t pid_processus_pere; |
pid_t pid_processus_pere; |
| pthread_t tid_processus_pere; |
pthread_t tid_processus_pere; |
|
Line 2216 typedef struct processus
|
Line 2495 typedef struct processus
|
| |
|
| logical1 processus_detache; |
logical1 processus_detache; |
| |
|
| |
enum t_type type_en_cours; |
| |
|
| /* Profilage */ |
/* Profilage */ |
| |
|
| logical1 profilage; |
logical1 profilage; |
|
Line 2224 typedef struct processus
|
Line 2505 typedef struct processus
|
| struct_liste_profilage2 *pile_profilage_fonctions; |
struct_liste_profilage2 *pile_profilage_fonctions; |
| struct timeval horodatage_profilage; |
struct timeval horodatage_profilage; |
| |
|
| // Mutex spécifique au processus et donnant accès à la pile des processus |
|
| pthread_mutex_t mutex; |
|
| pthread_mutex_t mutex_allocation; |
pthread_mutex_t mutex_allocation; |
| |
pthread_mutex_t mutex_allocation_buffer; |
| |
pthread_mutex_t mutex_interruptions; |
| |
pthread_mutex_t mutex_pile_processus; |
| |
pthread_mutex_t mutex_signaux; |
| |
|
| // Mutex autorisant les fork() |
// Mutex autorisant les fork() |
| sem_t __PTR__ semaphore_fork; |
sem_t __PTR__ semaphore_fork; |
|
Line 2237 typedef struct processus
|
Line 2520 typedef struct processus
|
| pthread_mutex_t protection_liste_mutexes; |
pthread_mutex_t protection_liste_mutexes; |
| unsigned int sections_critiques; |
unsigned int sections_critiques; |
| |
|
| /* Drapeau nécessaire à RESTART */ |
/* Variable d'initialisation pour SCHED */ |
| |
|
| |
logical1 initialisation_scheduler; |
| |
|
| |
/* Drapeau nécessaire à RESTART */ |
| |
|
| volatile logical1 requete_redemarrage; |
volatile logical1 requete_redemarrage; |
| |
|
| /* Gestion optimisée de la mémoire */ |
/* Gestion optimisée de la mémoire */ |
| |
|
| double estimation_taille_pile_tampon; |
double estimation_taille_pile_tampon; |
| unsigned long taille_pile_tampon; |
integer8 taille_pile_tampon; |
| struct_liste_chainee *pile_tampon; |
struct_liste_chainee *pile_tampon; |
| |
|
| double estimation_taille_pile_systeme_tampon; |
double estimation_taille_pile_systeme_tampon; |
| unsigned long taille_pile_systeme_tampon; |
integer8 taille_pile_systeme_tampon; |
| struct_liste_pile_systeme *pile_systeme_tampon; |
struct_liste_pile_systeme *pile_systeme_tampon; |
| |
|
| unsigned long taille_pile_objets; |
integer8 taille_pile_objets; |
| struct_objet *pile_objets; |
struct_objet *pile_objets; |
| |
|
| # define TAILLE_CACHE 16384 |
# define TAILLE_CACHE 1024 |
| |
# define CACHE(type, nom) \ |
| unsigned long *objets_adr[TAILLE_CACHE]; |
type *objets_##nom[TAILLE_CACHE]; \ |
| int pointeur_adr; |
volatile int pointeur_##nom; |
| |
|
| logical8 *objets_bin[TAILLE_CACHE]; |
# define CACHE2(type, nom) \ |
| int pointeur_bin; |
type *nom[TAILLE_CACHE]; \ |
| |
volatile int pointeur_##nom; |
| complex16 *objets_cpl[TAILLE_CACHE]; |
|
| int pointeur_cpl; |
CACHE(integer8, adr) |
| |
CACHE(logical8, bin) |
| struct fonction *objets_fct[TAILLE_CACHE]; |
CACHE(complex16, cpl) |
| int pointeur_fct; |
CACHE(struct_fonction, fct) |
| |
CACHE(integer8, int) |
| integer8 *objets_int[TAILLE_CACHE]; |
CACHE(struct_matrice, mat) |
| int pointeur_int; |
CACHE(struct_nom, nom) |
| |
CACHE(struct_record, rec) |
| struct_matrice *objets_mat[TAILLE_CACHE]; |
CACHE(real8, rel) |
| int pointeur_mat; |
CACHE(struct_tableau, tab) |
| |
CACHE(struct_vecteur, vec) |
| struct_nom *objets_nom[TAILLE_CACHE]; |
|
| int pointeur_nom; |
CACHE2(struct_liste_chainee, maillons) |
| |
CACHE2(struct_arbre_variables, variables_noeud) |
| real8 *objets_rel[TAILLE_CACHE]; |
CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud) |
| int pointeur_rel; |
CACHE2(struct_liste_variables, variables_feuille) |
| |
CACHE2(struct_variable, variables_variable) |
| struct_tableau *objets_tab[TAILLE_CACHE]; |
CACHE2(struct_arbre_variables *, variables_tableau_noeuds) |
| int pointeur_tab; |
CACHE2(struct_arbre_variables_partagees *, |
| |
variables_tableau_noeuds_partages) |
| struct_vecteur *objets_vec[TAILLE_CACHE]; |
|
| int pointeur_vec; |
CACHE2(struct_buffer, enveloppes_buffers) |
| |
unsigned char ***cache_buffer; |
| struct_liste_chainee *maillons[TAILLE_CACHE]; |
int *pointeur_cache_buffer; |
| int pointeur_maillons; |
} struct_processus; |
| |
#endif |
| |
|
| struct_arbre_variables *variables_noeud[TAILLE_CACHE]; |
#ifdef DEBUG_MEMOIRE |
| int pointeur_variables_noeud; |
pid_t debug_fork(struct_processus *s_etat_processus); |
| |
#endif |
| |
|
| struct_liste_variables *variables_feuille[TAILLE_CACHE]; |
|
| int pointeur_variables_feuille; |
|
| |
|
| struct_variable *variables_variable[TAILLE_CACHE]; |
/* |
| int pointeur_variables_variable; |
================================================================================ |
| |
MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE |
| |
================================================================================*/ |
| |
|
| struct_arbre_variables **variables_tableau_noeuds[TAILLE_CACHE]; |
#ifndef DEBUG_MEMOIRE |
| int pointeur_variables_tableau_noeuds; |
# define malloc(a) rpl_malloc(s_etat_processus, a) |
| } struct_processus; |
# define realloc(a, b) rpl_realloc(s_etat_processus, a, b) |
| |
# define free(a) rpl_free(s_etat_processus, a) |
| #endif |
#endif |
| |
|
| |
void *rpl_malloc(struct_processus *s_etat_processus, size_t s); |
| |
void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s); |
| |
void rpl_free(struct_processus *s_etat_processus, void *ptr); |
| |
void *sys_malloc(size_t s); |
| |
void *sys_realloc(void *ptr, size_t s); |
| |
void sys_free(void *ptr); |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
* Wrapper de readline() pour que la fonction renvoie un pointeur sur un |
| Structure fonction |
* buffer alloué par rpl_malloc(). |
| -------------------------------------------------------------------------------- |
*/ |
| */ |
|
| |
|
| #ifndef RPLARGS |
#define readline(s) readline_wrapper(s_etat_processus, s) |
| typedef struct fonction |
unsigned char *readline_wrapper(struct_processus *s_etat_processus, |
| { |
unsigned char *s); |
| unsigned char *nom_fonction; |
|
| unsigned long nombre_arguments; |
|
| |
|
| void (*fonction)(struct_processus *); |
|
| |
|
| volatile struct_liste_chainee *prediction_saut; |
|
| volatile logical1 prediction_execution; |
|
| } struct_fonction; |
|
| #endif |
|
| |
|
| |
|
| /* |
/* |
|
Line 2374 void instruction_ceil(struct_processus *
|
Line 2661 void instruction_ceil(struct_processus *
|
| void instruction_centr(struct_processus *s_etat_processus); |
void instruction_centr(struct_processus *s_etat_processus); |
| void instruction_cf(struct_processus *s_etat_processus); |
void instruction_cf(struct_processus *s_etat_processus); |
| void instruction_chr(struct_processus *s_etat_processus); |
void instruction_chr(struct_processus *s_etat_processus); |
| |
void instruction_cipher(struct_processus *s_etat_processus); |
| void instruction_clear(struct_processus *s_etat_processus); |
void instruction_clear(struct_processus *s_etat_processus); |
| void instruction_cllcd(struct_processus *s_etat_processus); |
void instruction_cllcd(struct_processus *s_etat_processus); |
| void instruction_clmf(struct_processus *s_etat_processus); |
void instruction_clmf(struct_processus *s_etat_processus); |
|
Line 2384 void instruction_clrcntxt(struct_process
|
Line 2672 void instruction_clrcntxt(struct_process
|
| void instruction_clrerr(struct_processus *s_etat_processus); |
void instruction_clrerr(struct_processus *s_etat_processus); |
| void instruction_clrfuse(struct_processus *s_etat_processus); |
void instruction_clrfuse(struct_processus *s_etat_processus); |
| void instruction_clrmtx(struct_processus *s_etat_processus); |
void instruction_clrmtx(struct_processus *s_etat_processus); |
| |
void instruction_clrsock(struct_processus *s_etat_processus); |
| void instruction_clrsmphr(struct_processus *s_etat_processus); |
void instruction_clrsmphr(struct_processus *s_etat_processus); |
| void instruction_clrswi(struct_processus *s_etat_processus); |
void instruction_clrswi(struct_processus *s_etat_processus); |
| void instruction_cls(struct_processus *s_etat_processus); |
void instruction_cls(struct_processus *s_etat_processus); |
|
Line 2394 void instruction_col_fleche(struct_proce
|
Line 2683 void instruction_col_fleche(struct_proce
|
| void instruction_col_moins(struct_processus *s_etat_processus); |
void instruction_col_moins(struct_processus *s_etat_processus); |
| void instruction_col_plus(struct_processus *s_etat_processus); |
void instruction_col_plus(struct_processus *s_etat_processus); |
| void instruction_comb(struct_processus *s_etat_processus); |
void instruction_comb(struct_processus *s_etat_processus); |
| |
void instruction_compress(struct_processus *s_etat_processus); |
| void instruction_con(struct_processus *s_etat_processus); |
void instruction_con(struct_processus *s_etat_processus); |
| void instruction_cond(struct_processus *s_etat_processus); |
void instruction_cond(struct_processus *s_etat_processus); |
| void instruction_cont(struct_processus *s_etat_processus); |
void instruction_cont(struct_processus *s_etat_processus); |
|
Line 2434 void instruction_detach(struct_processus
|
Line 2724 void instruction_detach(struct_processus
|
| void instruction_dft(struct_processus *s_etat_processus); |
void instruction_dft(struct_processus *s_etat_processus); |
| void instruction_dgtiz(struct_processus *s_etat_processus); |
void instruction_dgtiz(struct_processus *s_etat_processus); |
| void instruction_diag_fleche(struct_processus *s_etat_processus); |
void instruction_diag_fleche(struct_processus *s_etat_processus); |
| |
void instruction_digest(struct_processus *s_etat_processus); |
| void instruction_disp(struct_processus *s_etat_processus); |
void instruction_disp(struct_processus *s_etat_processus); |
| void instruction_division(struct_processus *s_etat_processus); |
void instruction_division(struct_processus *s_etat_processus); |
| void instruction_do(struct_processus *s_etat_processus); |
void instruction_do(struct_processus *s_etat_processus); |
|
Line 2460 void instruction_elseif(struct_processus
|
Line 2751 void instruction_elseif(struct_processus
|
| void instruction_end(struct_processus *s_etat_processus); |
void instruction_end(struct_processus *s_etat_processus); |
| void instruction_eng(struct_processus *s_etat_processus); |
void instruction_eng(struct_processus *s_etat_processus); |
| void instruction_epsilon(struct_processus *s_etat_processus); |
void instruction_epsilon(struct_processus *s_etat_processus); |
| |
void instruction_eqv(struct_processus *s_etat_processus); |
| void instruction_erase(struct_processus *s_etat_processus); |
void instruction_erase(struct_processus *s_etat_processus); |
| void instruction_errm(struct_processus *s_etat_processus); |
void instruction_errm(struct_processus *s_etat_processus); |
| void instruction_errn(struct_processus *s_etat_processus); |
void instruction_errn(struct_processus *s_etat_processus); |
|
Line 2596 void instruction_mtxtrylock(struct_proce
|
Line 2888 void instruction_mtxtrylock(struct_proce
|
| void instruction_mtxunlock(struct_processus *s_etat_processus); |
void instruction_mtxunlock(struct_processus *s_etat_processus); |
| void instruction_multiplication(struct_processus *s_etat_processus); |
void instruction_multiplication(struct_processus *s_etat_processus); |
| |
|
| |
void instruction_nbrcpus(struct_processus *s_etat_prorcessus); |
| void instruction_ne(struct_processus *s_etat_processus); |
void instruction_ne(struct_processus *s_etat_processus); |
| void instruction_neg(struct_processus *s_etat_processus); |
void instruction_neg(struct_processus *s_etat_processus); |
| void instruction_next(struct_processus *s_etat_processus); |
void instruction_next(struct_processus *s_etat_processus); |
|
Line 2685 void instruction_rdz(struct_processus *s
|
Line 2978 void instruction_rdz(struct_processus *s
|
| void instruction_re(struct_processus *s_etat_processus); |
void instruction_re(struct_processus *s_etat_processus); |
| void instruction_read(struct_processus *s_etat_processus); |
void instruction_read(struct_processus *s_etat_processus); |
| void instruction_recode(struct_processus *s_etat_processus); |
void instruction_recode(struct_processus *s_etat_processus); |
| |
void instruction_record(struct_processus *s_etat_processus); |
| void instruction_recv(struct_processus *s_etat_processus); |
void instruction_recv(struct_processus *s_etat_processus); |
| void instruction_redraw(struct_processus *s_etat_processus); |
void instruction_redraw(struct_processus *s_etat_processus); |
| void instruction_regex(struct_processus *s_etat_processus); |
void instruction_regex(struct_processus *s_etat_processus); |
|
Line 2700 void instruction_return(struct_processus
|
Line 2994 void instruction_return(struct_processus
|
| void instruction_revlist(struct_processus *s_etat_processus); |
void instruction_revlist(struct_processus *s_etat_processus); |
| void instruction_rewind(struct_processus *s_etat_processus); |
void instruction_rewind(struct_processus *s_etat_processus); |
| void instruction_rfuse(struct_processus *s_etat_processus); |
void instruction_rfuse(struct_processus *s_etat_processus); |
| |
void instruction_rgdl(struct_processus *s_etat_processus); |
| |
void instruction_rgdr(struct_processus *s_etat_processus); |
| void instruction_rl(struct_processus *s_etat_processus); |
void instruction_rl(struct_processus *s_etat_processus); |
| void instruction_rlb(struct_processus *s_etat_processus); |
void instruction_rlb(struct_processus *s_etat_processus); |
| void instruction_rnd(struct_processus *s_etat_processus); |
void instruction_rnd(struct_processus *s_etat_processus); |
|
Line 2819 void instruction_t_vers_l(struct_process
|
Line 3115 void instruction_t_vers_l(struct_process
|
| |
|
| void instruction_ucase(struct_processus *s_etat_processus); |
void instruction_ucase(struct_processus *s_etat_processus); |
| void instruction_uchol(struct_processus *s_etat_processus); |
void instruction_uchol(struct_processus *s_etat_processus); |
| |
void instruction_uncompress(struct_processus *s_etat_processus); |
| void instruction_unlock(struct_processus *s_etat_processus); |
void instruction_unlock(struct_processus *s_etat_processus); |
| void instruction_unprotect(struct_processus *s_etat_processus); |
void instruction_unprotect(struct_processus *s_etat_processus); |
| void instruction_until(struct_processus *s_etat_processus); |
void instruction_until(struct_processus *s_etat_processus); |
|
Line 2869 void instruction_yield(struct_processus
|
Line 3166 void instruction_yield(struct_processus
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| void affectation_interruptions_logicielles(struct_processus *s_etat_processus); |
void affectation_interruptions_logicielles(struct_processus *s_etat_processus); |
| void affichage_pile(struct_processus *s_etat_processus, |
void affichage_pile(struct_processus *s_etat_processus, |
| struct_liste_chainee *l_element_courant, unsigned long |
struct_liste_chainee *l_element_courant, integer8 niveau_courant); |
| niveau_courant); |
|
| #endif |
#endif |
| |
|
| void *allocation_maillon(struct_processus *s_etat_processus); |
void *allocation_maillon(struct_processus *s_etat_processus); |
|
Line 2888 void conversion_chaine(struct_processus
|
Line 3184 void conversion_chaine(struct_processus
|
| unsigned char *chaine, unsigned char type); |
unsigned char *chaine, unsigned char type); |
| void conversion_decimal_vers_hms(real8 *angle); |
void conversion_decimal_vers_hms(real8 *angle); |
| void conversion_degres_vers_radians(real8 *angle); |
void conversion_degres_vers_radians(real8 *angle); |
| void conversion_element_tex(unsigned char **element, unsigned char *fonction); |
void conversion_element_tex(struct_processus *s_etat_processus, |
| |
unsigned char **element, unsigned char *fonction); |
| void conversion_format(struct_processus *s_etat_processus, |
void conversion_format(struct_processus *s_etat_processus, |
| unsigned char *chaine); |
unsigned char *chaine); |
| void conversion_hms_vers_decimal(real8 *angle); |
void conversion_hms_vers_decimal(real8 *angle); |
| void conversion_majuscule_limitee(unsigned char *chaine_entree, |
void conversion_majuscule_limitee( |
| unsigned char *chaine_sortie, unsigned long longueur); |
unsigned char *chaine_entree, unsigned char *chaine_sortie, |
| |
integer8 longueur); |
| void conversion_radians_vers_degres(real8 *angle); |
void conversion_radians_vers_degres(real8 *angle); |
| void copie_arbre_variables(struct_processus *s_etat_processus, |
void copie_arbre_variables(struct_processus *s_etat_processus, |
| struct_processus *s_nouvel_etat_processus); |
struct_processus *s_nouvel_etat_processus); |
|
Line 2906 void determinant(struct_processus *s_eta
|
Line 3204 void determinant(struct_processus *s_eta
|
| void *valeur); |
void *valeur); |
| void deverrouillage_threads_concurrents(struct_processus *s_etat_processus); |
void deverrouillage_threads_concurrents(struct_processus *s_etat_processus); |
| void ecriture_pile(struct_processus *s_etat_processus, file *flux, |
void ecriture_pile(struct_processus *s_etat_processus, file *flux, |
| struct_liste_chainee *l_element_courant, unsigned long niveau_courant); |
struct_liste_chainee *l_element_courant, integer8 niveau_courant); |
| void ecriture_profil(struct_processus *s_etat_processus); |
void ecriture_profil(struct_processus *s_etat_processus); |
| void effacement_pile_systeme(struct_processus *s_etat_processus); |
void effacement_pile_systeme(struct_processus *s_etat_processus); |
| void empilement_pile_systeme(struct_processus *s_etat_processus); |
void empilement_pile_systeme(struct_processus *s_etat_processus); |
| void encart(struct_processus *s_etat_processus, unsigned long duree); |
void encart(struct_processus *s_etat_processus, integer8 duree); |
| void evaluation_romberg(struct_processus *s_etat_processus, |
void evaluation_romberg(struct_processus *s_etat_processus, |
| struct_objet *s_expression, unsigned char *variable, real8 *point, |
struct_objet *s_expression, unsigned char *variable, real8 *point, |
| real8 *valeur, logical1 *validite); |
real8 *valeur, logical1 *validite); |
|
Line 2931 void formateur_elementaire_tex(struct_pr
|
Line 3229 void formateur_elementaire_tex(struct_pr
|
| file *fichier, struct_objet *s_objet, unsigned char environnement); |
file *fichier, struct_objet *s_objet, unsigned char environnement); |
| void impression_pile(struct_processus *s_etat_processus, |
void impression_pile(struct_processus *s_etat_processus, |
| struct_liste_chainee *l_element_courant, |
struct_liste_chainee *l_element_courant, |
| unsigned char methode, unsigned long niveau_courant); |
unsigned char methode, integer8 niveau_courant); |
| void impression_tex(struct_processus *s_etat_processus); |
void impression_tex(struct_processus *s_etat_processus); |
| void informations(struct_processus *s_etat_processus); |
void informations(struct_processus *s_etat_processus); |
| void initialisation_allocateur(struct_processus *s_etat_processus); |
void initialisation_allocateur(struct_processus *s_etat_processus); |
|
Line 2939 void initialisation_completion(void);
|
Line 3237 void initialisation_completion(void);
|
| void initialisation_contexte_cas(struct_processus *s_etat_processus); |
void initialisation_contexte_cas(struct_processus *s_etat_processus); |
| void initialisation_drapeaux(struct_processus *s_etat_processus); |
void initialisation_drapeaux(struct_processus *s_etat_processus); |
| void initialisation_generateur_aleatoire(struct_processus *s_etat_processus, |
void initialisation_generateur_aleatoire(struct_processus *s_etat_processus, |
| logical1 initialisation_automatique, unsigned long int racine); |
logical1 initialisation_automatique, integer8 racine); |
| void initialisation_instructions(struct_processus *s_etat_processus); |
void initialisation_instructions(struct_processus *s_etat_processus); |
| void initialisation_variables(struct_processus *s_etat_processus); |
void initialisation_variables(struct_processus *s_etat_processus); |
| #endif |
#endif |
|
Line 2962 void interruption3(int signal);
|
Line 3260 void interruption3(int signal);
|
| void interruption4(int signal); |
void interruption4(int signal); |
| void interruption5(int signal); |
void interruption5(int signal); |
| void interruption6(int signal); |
void interruption6(int signal); |
| void interruption_depassement_pile(int urgence, stackoverflow_context_t scp); |
#ifdef HAVE_SIGSEGV_RECOVERY |
| |
void interruption_depassement_pile(int urgence, |
| |
stackoverflow_context_t scp); |
| |
#endif |
| void inversion_matrice(struct_processus *s_etat_processus, |
void inversion_matrice(struct_processus *s_etat_processus, |
| struct_matrice *s_matrice); |
struct_matrice *s_matrice); |
| void lancement_daemon(struct_processus *s_etat_processus); |
void lancement_daemon(struct_processus *s_etat_processus); |
|
Line 2979 void liberation_arbre_instructions(struc
|
Line 3280 void liberation_arbre_instructions(struc
|
| struct_instruction *arbre); |
struct_instruction *arbre); |
| void liberation_arbre_variables(struct_processus *s_etat_processus, |
void liberation_arbre_variables(struct_processus *s_etat_processus, |
| struct_arbre_variables *arbre, logical1 definitions); |
struct_arbre_variables *arbre, logical1 definitions); |
| |
void liberation_arbre_variables_partagees(struct_processus *s_etat_processus, |
| |
struct_arbre_variables_partagees *arbre); |
| void liberation_contexte_cas(struct_processus *s_etat_processus); |
void liberation_contexte_cas(struct_processus *s_etat_processus); |
| void liberation_generateur_aleatoire(struct_processus *s_etat_processus); |
void liberation_generateur_aleatoire(struct_processus *s_etat_processus); |
| |
void liberation_mutexes_arbre_variables_partagees(struct_processus |
| |
*s_etat_processus, struct_arbre_variables_partagees *l_element_courant); |
| void liberation_threads(struct_processus *s_etat_processus); |
void liberation_threads(struct_processus *s_etat_processus); |
| void liberation_profil(struct_processus *s_etat_processus); |
void liberation_profil(struct_processus *s_etat_processus); |
| void localisation_courante(struct_processus *s_etat_processus); |
void localisation_courante(struct_processus *s_etat_processus); |
|
Line 3004 void scrutation_injection(struct_process
|
Line 3309 void scrutation_injection(struct_process
|
| void scrutation_interruptions(struct_processus *s_etat_processus); |
void scrutation_interruptions(struct_processus *s_etat_processus); |
| void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau); |
void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau); |
| void *surveillance_processus(void *argument); |
void *surveillance_processus(void *argument); |
| void swap(void *variable_1, void *variable_2, unsigned long taille_octets); |
void swap(void *variable_1, void *variable_2, integer8 taille_octets); |
| |
void *thread_signaux(void *argument); |
| void trace(struct_processus *s_etat_processus, FILE *flux); |
void trace(struct_processus *s_etat_processus, FILE *flux); |
| void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus); |
void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus); |
| void traitement_exceptions_gsl(const char *reason, const char *file, |
void traitement_exceptions_gsl(const char *reason, const char *file, |
| int line, int gsl_errno); |
int line, int gsl_errno); |
| void traitement_interruptions_logicielles(struct_processus *s_etat_processus); |
void traitement_interruptions_logicielles(struct_processus *s_etat_processus); |
| void tri_base_symboles_externes(struct_processus *s_etat_processus); |
void tri_base_symboles_externes(struct_processus *s_etat_processus); |
| void tri_vecteur(real8 *vecteur, unsigned long taille); |
void tri_vecteur(real8 *vecteur, integer8 taille); |
| void valeurs_propres(struct_processus *s_etat_processus, |
void valeurs_propres(struct_processus *s_etat_processus, |
| struct_matrice *s_matrice, |
struct_matrice *s_matrice, |
| struct_vecteur *s_valeurs_propres, |
struct_vecteur *s_valeurs_propres, |
|
Line 3041 void liberation_queue_signaux(struct_pro
|
Line 3347 void liberation_queue_signaux(struct_pro
|
| void destruction_queue_signaux(struct_processus *s_etat_processus); |
void destruction_queue_signaux(struct_processus *s_etat_processus); |
| int envoi_signal_contexte(struct_processus *s_etat_processus, |
int envoi_signal_contexte(struct_processus *s_etat_processus, |
| enum signaux_rpl signal); |
enum signaux_rpl signal); |
| int envoi_signal_processus(pid_t pid, 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); |
logical1 test_ouverture); |
| |
int envoi_signal_thread(struct_processus *s_etat_processus, |
| |
pthread_t tid, enum signaux_rpl signal); |
| #endif |
#endif |
| |
|
| /* |
/* |
|
Line 3051 int envoi_signal_thread(pthread_t tid, e
|
Line 3359 int envoi_signal_thread(pthread_t tid, e
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| real8 sommation_vecteur_reel(real8 *vecteur, unsigned long *taille, |
real8 sommation_vecteur_reel(real8 *vecteur, integer8 *taille, |
| logical1 *erreur_memoire); |
logical1 *erreur_memoire); |
| complex16 sommation_vecteur_complexe(complex16 *vecteur, unsigned long *taille, |
complex16 sommation_vecteur_complexe(complex16 *vecteur, integer8 *taille, |
| logical1 *erreur_memoire); |
logical1 *erreur_memoire); |
| |
|
| /* |
/* |
|
Line 3075 int rplinit(int argc, char *argv[], char
|
Line 3383 int rplinit(int argc, char *argv[], char
|
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| real8 correlation_statistique(struct_matrice *s_matrice, |
real8 correlation_statistique(struct_matrice *s_matrice, |
| unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur); |
integer8 colonne_1, integer8 colonne_2, logical1 *erreur); |
| real8 covariance_statistique(struct_matrice *s_matrice, |
real8 covariance_statistique(struct_matrice *s_matrice, |
| unsigned long colonne_1, unsigned long colonne_2, |
integer8 colonne_1, integer8 colonne_2, |
| unsigned char type, logical1 *erreur); |
unsigned char type, logical1 *erreur); |
| struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice, |
struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus, |
| unsigned char type); |
struct_matrice *s_matrice, unsigned char type); |
| struct_vecteur *moyenne_statistique(struct_matrice *s_matrice); |
struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus, |
| struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice, |
struct_matrice *s_matrice); |
| unsigned long colonne); |
struct_vecteur *sommation_colonne_statistique( |
| struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice |
struct_processus *s_etat_processus, struct_matrice *s_matrice, |
| *s_matrice, unsigned long colonne_1, unsigned long colonne_2); |
integer8 colonne); |
| struct_vecteur *sommation_statistique(struct_matrice *s_matrice); |
struct_vecteur *sommation_produits_colonnes_statistiques( |
| struct_vecteur *variance_statistique(struct_matrice *s_matrice, |
struct_processus *s_etat_processus, struct_matrice |
| unsigned char type); |
*s_matrice, integer8 colonne_1, integer8 colonne_2); |
| |
struct_vecteur *sommation_statistique(struct_processus *s_etat_processus, |
| |
struct_matrice *s_matrice); |
| |
struct_vecteur *variance_statistique(struct_processus *s_etat_processus, |
| |
struct_matrice *s_matrice, unsigned char type); |
| #endif |
#endif |
| |
|
| /* |
/* |
|
Line 3111 struct_liste_chainee *depilement_pile_op
|
Line 3423 struct_liste_chainee *depilement_pile_op
|
| struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments |
struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments |
| *s_rpl_arguments, struct_objet *s_objet); |
*s_rpl_arguments, struct_objet *s_objet); |
| struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments |
struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments |
| *s_rpl_arguments, unsigned long nombre_arguments); |
*s_rpl_arguments, integer8 nombre_arguments); |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
|
Line 3122 struct_liste_chainee *sauvegarde_argumen
|
Line 3434 struct_liste_chainee *sauvegarde_argumen
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| unsigned char *analyse_algebrique(struct_processus *s_etat_processus, |
unsigned char *analyse_algebrique(struct_processus *s_etat_processus, |
| unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste); |
unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste); |
| |
#endif |
| unsigned char *analyse_flux(struct_processus *s_etat_processus, |
unsigned char *analyse_flux(struct_processus *s_etat_processus, |
| unsigned char *flux, long longueur); |
unsigned char *flux, integer8 longueur); |
| unsigned char *recherche_chemin_fichiers_temporaires(struct_processus |
#ifndef RPLARGS |
| *s_etat_processus); |
unsigned char *chiffrement(struct_processus *s_etat_processus, |
| unsigned char *compactage(unsigned char *chaine); |
const EVP_CIPHER *type_chiffrement, |
| unsigned char *conversion_majuscule(unsigned char *chaine); |
logical1 encodage, unsigned char *message, integer8 longueur_message, |
| |
unsigned char *clef, integer8 longueur_clef, |
| |
unsigned char *vecteur_initialisation, |
| |
integer8 *longueur_message_chiffre, |
| |
unsigned char padding); |
| |
unsigned char *compactage(struct_processus *s_etat_processus, |
| |
unsigned char *chaine); |
| |
unsigned char *conversion_majuscule(struct_processus *s_etat_processus, |
| |
unsigned char *chaine); |
| unsigned char *creation_nom_fichier(struct_processus *s_etat_processus, |
unsigned char *creation_nom_fichier(struct_processus *s_etat_processus, |
| unsigned char *chemin); |
unsigned char *chemin); |
| unsigned char *date_compilation(); |
unsigned char *date_compilation(struct_processus *s_etat_processus); |
| unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i, |
unsigned char *extraction_chaine(struct_processus *s_etat_processus, |
| unsigned long j); |
unsigned char *chaine, integer8 i, integer8 j); |
| unsigned char *formateur(struct_processus *s_etat_processus, long offset, |
unsigned char *formateur(struct_processus *s_etat_processus, long offset, |
| struct_objet *s_objet); |
struct_objet *s_objet); |
| unsigned char *formateur_fichier(struct_processus *s_etat_processus, |
unsigned char *formateur_fichier(struct_processus *s_etat_processus, |
| struct_objet *s_objet, struct_objet *s_format, |
struct_objet *s_objet, struct_objet *s_format, |
| long longueur, long longueur_champ, unsigned char format, |
integer8 longueur, integer8 longueur_champ, unsigned char format, |
| unsigned char type, long *longueur_effective, long *recursivite); |
unsigned char type, integer8 *longueur_effective, integer8 *recursivite, |
| |
logical1 export_fichier); |
| |
#endif |
| unsigned char *formateur_flux(struct_processus *s_etat_processus, |
unsigned char *formateur_flux(struct_processus *s_etat_processus, |
| unsigned char *donnees, long *longueur); |
unsigned char *donnees, integer8 *longueur); |
| |
#ifndef RPLARGS |
| unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus, |
unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type, |
void *valeur_numerique, unsigned char type, |
| long longueur, long longueur_champ, unsigned char format); |
integer8 longueur, integer8 longueur_champ, unsigned char format); |
| unsigned char *formateur_fichier_binaire_nombre(struct_processus |
unsigned char *formateur_fichier_binaire_nombre(struct_processus |
| *s_etat_processus, void *valeur_numerique, unsigned char type, |
*s_etat_processus, void *valeur_numerique, unsigned char type_entree, |
| long longueur, long *longueur_conversion); |
unsigned char type, integer8 longueur, integer8 *longueur_conversion); |
| unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus, |
unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type, |
void *valeur_numerique, unsigned char type, |
| long longueur, long longueur_champ, unsigned char format); |
integer8 longueur, integer8 longueur_champ, unsigned char format); |
| unsigned char *formateur_nombre(struct_processus *s_etat_processus, |
unsigned char *formateur_nombre(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type); |
void *valeur_numerique, unsigned char type); |
| unsigned char *formateur_reel(struct_processus *s_etat_processus, |
unsigned char *formateur_reel(struct_processus *s_etat_processus, |
|
Line 3157 unsigned char *formateur_reel(struct_pro
|
Line 3481 unsigned char *formateur_reel(struct_pro
|
| unsigned char *messages(struct_processus *s_etat_processus); |
unsigned char *messages(struct_processus *s_etat_processus); |
| unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus, |
unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus, |
| unsigned char *chaine, integer8 position); |
unsigned char *chaine, integer8 position); |
| unsigned char *purification_chaine(unsigned char *chaine); |
unsigned char *purification_chaine(struct_processus *s_etat_processus, |
| |
unsigned char *chaine); |
| |
unsigned char *recherche_chemin_fichiers_temporaires(struct_processus |
| |
*s_etat_processus); |
| unsigned char *reencodage(struct_processus *s_etat_processus, |
unsigned char *reencodage(struct_processus *s_etat_processus, |
| unsigned char *chaine_entree, unsigned char *codage_entree, |
unsigned char *chaine_entree, unsigned char *codage_entree, |
| unsigned char *codage_sortie); |
unsigned char *codage_sortie); |
|
Line 3174 unsigned char *transliteration(struct_pr
|
Line 3501 unsigned char *transliteration(struct_pr
|
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| logical1 analyse_syntaxique(struct_processus *s_etat_processus); |
logical1 analyse_syntaxique(struct_processus *s_etat_processus); |
| |
logical1 arret_thread_signaux(struct_processus *s_etat_processus); |
| logical1 caracteristiques_fichier(struct_processus *s_etat_processus, |
logical1 caracteristiques_fichier(struct_processus *s_etat_processus, |
| unsigned char *nom, logical1 *existence, logical1 *ouverture, |
unsigned char *nom, logical1 *existence, logical1 *ouverture, |
| unsigned long *unite); |
unsigned long *unite); |
|
Line 3197 logical1 destruction_fichier(unsigned ch
|
Line 3525 logical1 destruction_fichier(unsigned ch
|
| logical1 empilement(struct_processus *s_etat_processus, |
logical1 empilement(struct_processus *s_etat_processus, |
| struct_liste_chainee **l_base_liste, struct_objet *s_objet); |
struct_liste_chainee **l_base_liste, struct_objet *s_objet); |
| logical1 empilement_pile_last(struct_processus *s_etat_processus, |
logical1 empilement_pile_last(struct_processus *s_etat_processus, |
| unsigned long nombre_arguments); |
integer8 nombre_arguments); |
| logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet, |
logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet, |
| unsigned char type_evaluation); |
unsigned char type_evaluation); |
| logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus, |
logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus, |
| sqlite3 *sqlite, logical1 binaire); |
sqlite3 *sqlite, logical1 binaire); |
| logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus, |
logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus, |
| sqlite3 *sqlite, integer8 position_clef, logical1 binaire); |
sqlite3 *sqlite, integer8 position_clef, logical1 binaire); |
| |
logical1 lancement_thread_signaux(struct_processus *s_etat_processus); |
| logical1 recherche_instruction_suivante(struct_processus *s_etat_processus); |
logical1 recherche_instruction_suivante(struct_processus *s_etat_processus); |
| |
logical1 recherche_instruction_suivante_recursive( |
| |
struct_processus *s_etat_processus, integer8 recursivite); |
| logical1 retrait_variable(struct_processus *s_etat_processus, |
logical1 retrait_variable(struct_processus *s_etat_processus, |
| unsigned char *nom_variable, unsigned char type); |
unsigned char *nom_variable, unsigned char type); |
| logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus); |
logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus); |
| logical1 retrait_variable_partagee(struct_processus *s_etat_processus, |
logical1 retrait_variable_partagee(struct_processus *s_etat_processus, |
| unsigned char *nom_variable, union_position_variable position); |
unsigned char *nom_variable, union_position_variable position); |
| logical1 retrait_variables_statiques_locales( |
logical1 retrait_variables_partagees_locales( |
| struct_processus *s_etat_processus); |
struct_processus *s_etat_processus); |
| logical1 retrait_variable_statique(struct_processus *s_etat_processus, |
logical1 retrait_variable_statique(struct_processus *s_etat_processus, |
| unsigned char *nom_variable, union_position_variable position); |
unsigned char *nom_variable, union_position_variable position); |
| |
logical1 retrait_variables_statiques_locales( |
| |
struct_processus *s_etat_processus); |
| logical1 sequenceur(struct_processus *s_etat_processus); |
logical1 sequenceur(struct_processus *s_etat_processus); |
| logical1 sequenceur_optimise(struct_processus *s_etat_processus); |
logical1 sequenceur_optimise(struct_processus *s_etat_processus, |
| |
struct_liste_chainee *l_bibliotheques); |
| #endif |
#endif |
| |
|
| /* |
/* |
|
Line 3227 logical1 sequenceur_optimise(struct_proc
|
Line 3561 logical1 sequenceur_optimise(struct_proc
|
| logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat); |
logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat); |
| logical1 depassement_multiplication(integer8 *a, integer8 *b, |
logical1 depassement_multiplication(integer8 *a, integer8 *b, |
| integer8 *resultat); |
integer8 *resultat); |
| |
logical1 depassement_soustraction(integer8 *a, integer8 *b, integer8 *resultat); |
| logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat); |
logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat); |
| |
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
|
Line 3236 logical1 recherche_variable(struct_proce
|
Line 3571 logical1 recherche_variable(struct_proce
|
| unsigned char *nom_variable); |
unsigned char *nom_variable); |
| logical1 recherche_variable_globale(struct_processus *s_etat_processus, |
logical1 recherche_variable_globale(struct_processus *s_etat_processus, |
| unsigned char *nom_variable); |
unsigned char *nom_variable); |
| logical1 recherche_variable_partagee(struct_processus *s_etat_processus, |
|
| unsigned char *nom_variable, union_position_variable position, |
|
| unsigned char origine); |
|
| logical1 test_cfsf(struct_processus *s_etat_processus, |
logical1 test_cfsf(struct_processus *s_etat_processus, |
| unsigned char indice_drapeau); |
unsigned char indice_drapeau); |
| logical1 test_expression_rpn(unsigned char *chaine); |
logical1 test_expression_rpn(unsigned char *chaine); |
|
Line 3255 logical1 validation_chaine(unsigned char
|
Line 3587 logical1 validation_chaine(unsigned char
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| ssize_t read_atomic(struct_processus *s_etat_processus, |
ssize_t read_atomic(struct_processus *s_etat_processus, |
| int fd, void *buf, size_t count); |
int fd, void *buf, size_t count); |
| |
ssize_t read_atomic_signal(struct_processus *s_etat_processus, |
| |
int fd, void *buf, size_t count); |
| ssize_t write_atomic(struct_processus *s_etat_processus, |
ssize_t write_atomic(struct_processus *s_etat_processus, |
| int fd, void *buf, size_t count); |
int fd, void *buf, size_t count); |
| #endif |
#endif |
|
Line 3265 ssize_t write_atomic(struct_processus *s
|
Line 3599 ssize_t write_atomic(struct_processus *s
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| int alsprintf(unsigned char **strp, const char *fmt, ...); |
int alsprintf(struct_processus *s_etat_processus, |
| |
unsigned char **strp, const char *fmt, ...); |
| |
#ifndef RPLARGS |
| |
int association_etat_processus_readline(); |
| |
#endif |
| int interruption_violation_access(void *adresse_fautive, int gravite); |
int interruption_violation_access(void *adresse_fautive, int gravite); |
| #ifndef RPLARGS |
#ifndef RPLARGS |
| int liste_variables(struct_processus *s_etat_processus, |
int initialisation_etat_processus_readline(); |
| struct_tableau_variables *tableau, int position, |
int liberation_etat_processus_readline(); |
| struct_arbre_variables *l_element_courant); |
integer8 liste_variables(struct_processus *s_etat_processus, |
| int nombre_variables(struct_processus *s_etat_processus, |
struct_tableau_variables *tableau); |
| struct_arbre_variables *l_element_courant); |
integer8 nombre_variables(struct_processus *s_etat_processus); |
| int readline_analyse_syntaxique(int count, int key); |
int readline_analyse_syntaxique(int count, int key); |
| int readline_effacement(int count, int key); |
int readline_effacement(int count, int key); |
| #endif |
#endif |
| |
int std_fprintf(file *flux, const char *format, ...); |
| int tex_fprintf(struct_processus *s_etat_processus, |
int tex_fprintf(struct_processus *s_etat_processus, |
| file *flux, const char *format, ...); |
file *flux, const char *format, ...); |
| int transliterated_fprintf(struct_processus *s_etat_processus, file *flux, |
int transliterated_fprintf(struct_processus *s_etat_processus, file *flux, |
| const char *format, ...); |
const char *format, ...); |
| int valsprintf(unsigned char **strp, const char *fmt, va_list ap); |
int valsprintf(struct_processus *s_etat_processus, |
| |
unsigned char **strp, const char *fmt, va_list ap); |
| int wrapper_instruction_intrinseque(void (*fonction)(), |
int wrapper_instruction_intrinseque(void (*fonction)(), |
| struct_rpl_arguments *rpl_arguments); |
struct_rpl_arguments *rpl_arguments); |
| |
|
|
Line 3331 struct_liste_chainee *analyse_rpn(struct
|
Line 3671 struct_liste_chainee *analyse_rpn(struct
|
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| |
Allocateur de buffers à cache |
| |
-------------------------------------------------------------------------------- |
| |
*/ |
| |
|
| |
void initialisation_allocateur_buffer(struct_processus *s_etat_processus); |
| |
void liberation_allocateur_buffer(struct_processus *s_etat_pocessus); |
| |
struct_buffer *allocation_buffer(struct_processus *s_etat_processus, |
| |
size_t longueur); |
| |
void liberation_buffer(struct_processus *s_etat_processus, |
| |
struct_buffer *buffer); |
| |
|
| |
/* |
| |
-------------------------------------------------------------------------------- |
| Fonctions renvoyant une copie de la structure de description des processus |
Fonctions renvoyant une copie de la structure de description des processus |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
|
Line 3364 struct_objet *allocation(struct_processu
|
Line 3717 struct_objet *allocation(struct_processu
|
| #ifndef RPLARGS |
#ifndef RPLARGS |
| struct_objet *formateur_date(struct_processus *s_etat_processus, |
struct_objet *formateur_date(struct_processus *s_etat_processus, |
| struct timeval *temps); |
struct timeval *temps); |
| |
struct_objet *lecture_fichier_non_formate(struct_processus *s_etat_processus, |
| |
void *argument, integer8 longueur_buffer, logical1 recursivite); |
| struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe); |
struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe); |
| struct_objet *parametres_sql(struct_processus *s_etat_processus, |
struct_objet *parametres_sql(struct_processus *s_etat_processus, |
| struct_objet *s_parametres); |
struct_objet *s_parametres); |
|
Line 3377 struct_arbre_variables **allocation_tabl
|
Line 3732 struct_arbre_variables **allocation_tabl
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques |
Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques |
| |
ou *struct_liste_variables_partagees |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| struct_liste_variables_statiques *recherche_variable_statique(struct_processus |
struct_liste_variables_statiques *recherche_variable_statique(struct_processus |
| *s_etat_processus, unsigned char *nom_variable, |
*s_etat_processus, unsigned char *nom_variable, |
| union_position_variable position, |
union_position_variable position, unsigned char origine); |
| unsigned char origine); |
struct_liste_variables_partagees *recherche_variable_partagee(struct_processus |
| #endif |
*s_etat_processus, unsigned char *nom_variable, |
| |
union_position_variable position, unsigned char origine); |
| /* |
|
| -------------------------------------------------------------------------------- |
|
| Fonctions gérant les arbres de simplification |
|
| -------------------------------------------------------------------------------- |
|
| */ |
|
| |
|
| #ifndef RPLARGS |
|
| struct_arbre *creation_arbre(struct_processus *s_etat_processus, |
|
| struct_objet **t_objets, unsigned long indice, |
|
| unsigned long 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 |
#endif |
| |
|
| /* |
/* |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rpl.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src