rpl/src/rpl.h - diff

Return to rpl.h CVS log

Up to [local] / rpl / src

Diff for /rpl/src/rpl.h between versions 1.14 and 1.256

version 1.14, 2010/03/05 11:20:09	version 1.256, 2015/01/08 08:46:22
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.12	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2015 Dr. BERTRAND JoÃ«l

This file is part of RPL/2.	This file is part of RPL/2.

Line 23	Line 23
#ifndef INCLUSION_RPL	#ifndef INCLUSION_RPL
#define INCLUSION_RPL	#define INCLUSION_RPL

#define _GNU_SOURCE	#ifndef __RPLCAS
	# define _GNU_SOURCE
	# define _XOPEN_SOURCE 700
	#endif

#define _REENTRANT	#define _REENTRANT

// Nécessaire pour les systèmes qui ne comprennent pas _GNU_SOURCE	#ifndef __RPLCAS
#define _XOPEN_SOURCE 500	# ifdef Darwin
	# define _DARWIN_C_SOURCE
	# endif

	# ifdef OpenBSD
	# define _BSD_SOURCE
	# endif
	#endif

	#ifdef OS2
	# ifndef __RPLCAS
	# define _BSD_SOURCE
	# endif

	# include <types.h>
	enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
	# define SHUT_RD SHUT_RD
	# define SHUT_WR SHUT_WR
	# define SHUT_RDWR SHUT_RDWR

	# include "getaddrinfo-conv.h"

	# define sched_yield(arg)
	#endif

	#ifdef CYGWIN
	# define SA_ONSTACK 0
	#endif


/*	/*
================================================================================	================================================================================
Line 37	Line 69

#include <stdio.h>	#include <stdio.h>
#include <stdlib.h>	#include <stdlib.h>
	#include <stdint.h>
#include <math.h>	#include <math.h>
#include <string.h>	#include <string.h>
#include <strings.h>	#include <strings.h>
#include <syslog.h>	#include <syslog.h>
#include <errno.h>	#include <errno.h>
	#include <stdarg.h>
	#include <poll.h>
	#include <signal.h>

#ifndef RPLARGS	#ifndef RPLARGS
	# 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/time.h>
# include <sys/timeb.h>	# include <sys/timeb.h>
# include <sys/types.h>	# include <sys/types.h>
# include <sys/un.h>	# include <sys/un.h>
Line 61	Line 98
# include <dlfcn.h>	# include <dlfcn.h>
# include <fcntl.h>	# include <fcntl.h>
# include <pthread.h>	# include <pthread.h>
	# include <regex.h>

	# ifdef OS2
	# undef pthread_mutexattr_settype
	# define pthread_mutexattr_settype(a, b)
	# endif

# include <pwd.h>	# include <pwd.h>
# include <semaphore.h>	# ifdef SHARED_MEMORY
	# include <sys/shm.h>
	# endif

	# ifndef IPCS_SYSV
	# include <semaphore.h>
	# else
	# include <sys/ipc.h>
	# include <sys/sem.h>

	# ifdef OS2
	# define INCL_DOSSEMAPHORES
	# define INCL_DOSMEMMGR
	# define INCL_DOSERRORS
	# include <os2.h>

	typedef struct _OS2SEM
	{
	HMTX hmtx;
	HEV hev;
	ULONG shared;
	ULONG *cnt;
	ULONG *nopened;
	ULONG allocated;
	} sem_t;
	# else // IPCS_SYSV
	typedef struct
	{
	int sem;
	int alloue;
	unsigned char *path;
	pid_t pid;
	pthread_t tid;
	} sem_t;
	# endif

	# ifndef SEM_FAILED
	# define SEM_FAILED NULL
	# endif

	sem_t sem_open_SysV(const char nom, int oflag, ...);
	int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
	int sem_close_SysV(sem_t *sem);
	int sem_wait_SysV(sem_t *sem);
	int sem_trywait_SysV(sem_t *sem);
	int sem_timedwait_SysV(sem_t sem, struct timespec ts);
	int sem_post_SysV(sem_t *sem);
	int sem_getvalue_SysV(sem_t sem, int value);
	int sem_unlink_SysV(char *nom);
	int sem_destroy_SysV(sem_t *sem);
	# 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 74	Line 168
# include "readline.h"	# include "readline.h"
# include "termcap.h"	# include "termcap.h"
# include "iconv.h"	# include "iconv.h"
	# include "zlib.h"

# include "openssl/evp.h"	# include "openssl/evp.h"
	# ifndef OPENSSL_NO_MD2
	# include "openssl/md2.h"
	# endif
	# ifndef OPENSSL_NO_MD4
	# include "openssl/md4.h"
	# endif
	# ifndef OPENSSL_NO_MD5
	# include "openssl/md5.h"
	# endif
	# ifndef OPENSSL_NO_MDC2
	# include "openssl/mdc2.h"
	# endif
	# ifndef OPENSSL_NO_RIPEMD
	# include "openssl/ripemd.h"
	# endif
	# ifndef OPENSSL_NO_SHA
	# include "openssl/sha.h"
	# endif
	# ifndef OPENSSL_NO_WHIRLPOOL
	# include "openssl/whrlpool.h"
	# endif
	# ifndef OPENSSL_NO_AES
	# include "openssl/aes.h"
	# endif
	# ifndef OPENSSL_NO_CAMELLIA
	# include "openssl/camellia.h"
	# endif
	# ifndef OPENSSL_NO_RC2
	# include "openssl/rc2.h"
	# endif
	# ifndef OPENSSL_NO_IDEA
	# include "openssl/idea.h"
	# endif

	# include "sqlite3.h"
	# include "sigsegv.h"
	# ifdef OS2
	// Bug de libsigsegv
	# undef HAVE_STACK_OVERFLOW_RECOVERY
	# endif

# define HAVE_INLINE	# define HAVE_INLINE
# define GSL_RANGE_CHECK_OFF	# define GSL_RANGE_CHECK_OFF
Line 93	Line 228
# include <ieeefp.h>	# include <ieeefp.h>
#endif	#endif

	// DÃ©finition spÃ©cifique Ã Hurd
	#ifndef PIPE_BUF
	# define fpathconf (".", _PC_PIPE_BUF)
	#endif

#ifdef MYSQL_SUPPORT	#ifdef MYSQL_SUPPORT
# include <mysql.h>	# include <mysql.h>
# define mysqlclose(arg) mysql_close(arg.mysql)	# define mysqlclose(arg) mysql_close(arg.mysql)
Line 107	Line 247
# define postgresqlclose(arg)	# define postgresqlclose(arg)
#endif	#endif

#ifdef LIBRPL	#include "librplprototypes.h"
# include "librplprototypes.h"
	#ifndef RPLARGS
	# ifndef UNIX_PATH_MAX
	struct sockaddr_un sizecheck;
	# define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
	# endif
	#endif

	#ifdef MAIN_RPL
	# define __EXTERN__
	# define __STATIC_MUTEX_INITIALIZATION__ = PTHREAD_MUTEX_INITIALIZER
	#else
	# define __EXTERN__ extern
	# define __STATIC_MUTEX_INITIALIZATION__
#endif	#endif

/*	/*
================================================================================	================================================================================
	Bugs spÃ©cifiques
	================================================================================
	*/

	// NÃ©ant

	/*
	================================================================================
	TYPES
	================================================================================
	*/

	typedef FILE file;
	typedef unsigned char t_8_bits;

	#ifndef RPLARGS
	# include "rpltypes-conv.h"
	#else
	# include "rpltypes.h"
	#endif

	enum signaux_rpl
	{
	rpl_signull = 0,
	rpl_sigint,
	rpl_sigterm,
	rpl_sigstart, // Signal envoyÃ© par un pÃ¨re pour lancer son fils.
	rpl_sigcont, // Signal de redÃ©marrage d'un processus arrÃªtÃ© par
	// SUSPEND
	rpl_sigstop, // Signal d'arrÃªt envoyÃ© par l'instruction STOP ou
	// FUSE. (FSTOP)
	rpl_sigabort, // Signal envoyÃ© par l'instruction ABORT (Ã regrouper
	// avec FABORT)
	rpl_sigurg, // Signal d'arrÃªt urgent
	rpl_siginject, // Signal indiquant la prÃ©sence d'une donnÃ©e Ã lire
	// envoyÃ©e depuis le pÃ¨re
	rpl_sigalrm, // Signal d'alarme (erreur systÃ¨me) depuis un fils
	rpl_sighup,
	rpl_sigtstp,
	rpl_sigexcept,
	rpl_sigmax
	};

	#define LONGUEUR_QUEUE_SIGNAUX 1024

	// Une structure s_queue_signaux est crÃ©Ã©e par processus (et non par thread).
	// Elle est projetÃ©e dans un segment de mÃ©moire partagÃ©e pour qu'elle soit
	// accessible Ã la fois du pÃ¨re et des fils.

	#ifndef RPLARGS
	typedef struct queue_signaux
	{
	volatile int pointeur_lecture;
	volatile int pointeur_ecriture;
	volatile logical1 requete_arret;

	pthread_t thread_signaux;

	volatile struct
	{
	pid_t pid;
	enum signaux_rpl signal;
	} queue[LONGUEUR_QUEUE_SIGNAUX];

	# ifdef OS2
	sem_t semaphore;
	sem_t signalisation;
	sem_t arret_signalisation;
	# endif
	} struct_queue_signaux;

	__EXTERN__ struct_queue_signaux *s_queue_signaux;
	__EXTERN__ int f_queue_signaux;

	# ifndef OS2
	__EXTERN__ sem_t *semaphore_queue_signaux;
	__EXTERN__ sem_t *semaphore_signalisation;
	__EXTERN__ sem_t *semaphore_arret_signalisation;
	# endif
	#endif

	#ifdef OS2
	# define readline(s) readline_wrapper(s)
	unsigned char readline_wrapper(unsigned char s);
	#endif

	#if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)
	union semun
	{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
	struct seminfo *__buf;
	};
	#endif

	#ifndef RTLD_LOCAL
	# define RTLD_LOCAL 0
	#endif

	#ifndef SIGSTKSZ
	# define SIGSTKSZ 65536
	#endif

	/*
	================================================================================
	SÃ‰MAPHORES
	================================================================================
	*/

	#ifdef IPCS_SYSV
	# ifdef DEBUG_SEMAPHORES
	# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
	uprintf("[%d-%llu] Semaphore %s (%p) "\
	"waiting at %s() " \
	"line #%d\n", (int) getpid(), (unsigned long long) i\
	pthread_self(), \
	#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
	if (value > 1) BUG(1, uprintf("Value %d\n", value)); \
	sem_wait_SysV(a); })
	# define sem_post(a) ({ int value; sem_getvalue(a, &value); \
	uprintf("[%d-%llu] Semaphore %s (%p) "\
	"posting at %s() " \
	"line #%d\n", (int) getpid(), (unsigned long long) \
	pthread_self(), \
	#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
	if (value > 0) BUG(1, uprintf("Value %d\n", value)); \
	sem_post_SysV(a); })
	# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
	if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
	sem_destroy_SysV(a); })
	# else
	# define sem_destroy(a) sem_destroy_SysV(a)
	# define sem_wait(a) sem_wait_SysV(a)
	# define sem_post(a) sem_post_SysV(a)
	# endif

	# define sem_init(a, b, c) sem_init_SysV(a, b, c)
	# define sem_trywait(a) sem_trywait_SysV(a)
	# define sem_timedwait(a, b) sem_timedwait_SysV(a, b)
	# define sem_getvalue(a, b) sem_getvalue_SysV(a, b)
	# define sem_open(...) sem_open_SysV(__VA_ARGS__)
	# define sem_close(a) sem_close_SysV(a)
	# define sem_unlink(a) sem_unlink_SysV(a)
	#else
	# ifdef DEBUG_SEMAPHORES
	# define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
	uprintf("[%d-%llu] Semaphore %s (%p) "\
	"waiting at %s() " \
	"line #%d\n", (int) getpid(), (unsigned long long) \
	pthread_self(), \
	#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
	if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); })
	# define sem_post(a) ({ int value; sem_getvalue(a, &value); \
	uprintf("[%d-%llu] Semaphore %s (%p) "\
	"posting at %s() " \
	"line #%d\n", (int) getpid(), (unsigned long long) \
	pthread_self(), \
	#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
	if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); })
	# define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
	if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
	sem_destroy(a); })
	# endif
	#endif


	/*
	================================================================================
SIGNAUX	SIGNAUX
================================================================================	================================================================================
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
# define SIGFSTOP SIGUSR1
# define SIGSTART SIGUSR2	// Signaux utilisÃ©s par dÃ©faut :
# define SIGINJECT SIGQUIT	// SIGINT
# define SIGABORT SIGPROF	// SIGTSTP
	// SIGCONT
	// SIGPIPE
	// SIGUSR1 et SIGUSR2 sont utilisÃ© par libsigsegv.
	// SIGHUP
	// SIGALRM

	# define SIGTEST 255

	// Nombre d'interruptions disponibles
# define d_NOMBRE_INTERRUPTIONS 64	# define d_NOMBRE_INTERRUPTIONS 64
#endif	#endif

/*	/*
================================================================================	================================================================================
Granularité temporelle	GranularitÃ© temporelle
================================================================================	================================================================================
*/	*/

Line 162	Line 493

/*	/*
================================================================================	================================================================================
TYPES
================================================================================
*/

typedef FILE file;
typedef unsigned char t_8_bits;

#ifndef RPLARGS
# include "rpltypes.conv.h"
#else
# include "rpltypes.h"
#endif

/*
================================================================================
Variables globales	Variables globales
================================================================================	================================================================================
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
# ifndef MAIN_RPL	# ifdef SEMAPHORES_NOMMES
extern jmp_buf contexte;	# define LONGUEUR_NOM_SEMAPHORE 64
extern jmp_buf contexte_initial;	# define __PTR__ *

extern pthread_key_t semaphore_fork_processus_courant;

extern sem_t semaphore_liste_threads;
extern sem_t semaphore_gestionnaires_signaux;
extern sem_t semaphore_gestionnaires_signaux_atomique;
# else	# else
jmp_buf contexte;	# define __PTR__
jmp_buf contexte_initial;

pthread_key_t semaphore_fork_processus_courant;

sem_t semaphore_liste_threads;
sem_t semaphore_gestionnaires_signaux;
sem_t semaphore_gestionnaires_signaux_atomique;
# endif	# endif

	__EXTERN__ jmp_buf contexte_ecriture;
	__EXTERN__ jmp_buf contexte_impression;
	__EXTERN__ jmp_buf contexte_initial;
	__EXTERN__ jmp_buf contexte_processus;
	__EXTERN__ jmp_buf contexte_thread;

	__EXTERN__ volatile int signal_test;

	__EXTERN__ pid_t pid_processus_pere;

	__EXTERN__ pthread_mutex_t mutex_liste_threads
	__STATIC_MUTEX_INITIALIZATION__;
	__EXTERN__ pthread_mutex_t mutex_creation_variable_partagee
	__STATIC_MUTEX_INITIALIZATION__;
	__EXTERN__ pthread_mutex_t mutex_sections_critiques;
	__EXTERN__ pthread_mutex_t mutex_liste_variables_partagees;
	__EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__;

	__EXTERN__ volatile int routine_recursive;

	# define SEM_FORK 0
	# define SEM_QUEUE 1
	# define SEM_SIGNALISATION 2
	# define SEM_ARRET_SIGNALISATION 3

	sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);
	sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);
	int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);
	int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre);
	int sem_getvalue2(sem_t semaphore, int valeur);
	sem_t *sem_open2(pid_t pid, int ordre);
	#endif

	// Le mutex est lÃ uniquement pour pouvoir Ã©muler le comportement
	// de sem_getvalue() sur un systÃ¨me comme MacOS X qui ne possÃ¨de pas
	// cette fonction.

	#ifdef Darwin
	#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
	#define sem_post(semaphore) \
	({ int r; pthread_mutex_lock(&mutex_sem); \
	r = sem_post(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
	#define sem_wait(semaphore) \
	({ int r; pthread_mutex_lock(&mutex_sem); \
	r = sem_wait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
	#define sem_trywait(semaphore) \
	({ int r; pthread_mutex_lock(&mutex_sem); \
	r = sem_trywait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
#endif	#endif

/*	/*
Line 209 typedef unsigned char t_8_bits;	Line 561 typedef unsigned char t_8_bits;
================================================================================	================================================================================
*/	*/

// Par défaut, tout est redirigé vers stderr sauf indication explicite de	// Par dÃ©faut, tout est redirigÃ© vers stderr sauf indication explicite de
// stdout.	// stdout.

#define printf(...) transliterated_fprintf(s_etat_processus, \	#define printf(...) transliterated_fprintf(s_etat_processus, \
Line 221 typedef unsigned char t_8_bits;	Line 573 typedef unsigned char t_8_bits;
#define ufprintf(flux, ...) transliterated_fprintf(NULL, \	#define ufprintf(flux, ...) transliterated_fprintf(NULL, \
flux, __VA_ARGS__)	flux, __VA_ARGS__)

// Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr.
// Cela évite aux messages envoyés par les gestionnaires de signaux d'être
// indéfiniment bloqués.

#ifdef SunOS	#ifdef SunOS
# define fopen(...) ({ FILE *desc; \	# define fopen(...) ({ FILE *desc; \
while((desc = fopen(__VA_ARGS__)) == NULL) \	while((desc = fopen(__VA_ARGS__)) == NULL) \
{ if ((errno != EINTR) && (errno != 0)) break; } desc; })	{ if ((errno != EINTR) && (errno != 0)) break; } desc; })
	# define freopen(...) ({ FILE *desc; \
	while((desc = freopen(__VA_ARGS__)) == NULL) \
	{ if ((errno != EINTR) && (errno != 0)) break; } desc; })
# define fclose(...) ({ int ios; \	# define fclose(...) ({ int ios; \
while((ios = fclose(__VA_ARGS__)) != 0) \	while((ios = fclose(__VA_ARGS__)) != 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })	{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
# define fread(...) ({ int ios; \
while((ios = fread(__VA_ARGS__)) < 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
# define fflush(flux) ({ int ios; \	# define fflush(flux) ({ int ios; \
while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \	while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })	{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
Line 245 typedef unsigned char t_8_bits;	Line 593 typedef unsigned char t_8_bits;
# define fflush(flux) fflush((flux == stdout) ? stderr : flux)	# define fflush(flux) fflush((flux == stdout) ? stderr : flux)
#endif	#endif

// Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur	// Ajout d'un timeout sur les fonctions pipe() pour Ã©viter une erreur
// système dans le cas où l'on a atteint le nombre maximale de fichiers	// systÃ¨me dans le cas oÃ¹ l'on a atteint le nombre maximale de fichiers
// ouverts.	// ouverts.

#define pipe(descripteurs) \	#define pipe(descripteurs) \
Line 265 typedef unsigned char t_8_bits;	Line 613 typedef unsigned char t_8_bits;
erreur; \	erreur; \
})	})

// Redéfinition de abs pour un fonctionnement en entier de type long long int	// RedÃ©finition de abs pour un fonctionnement en entier de type long long int

#if 1	#ifdef __GNUC__
# define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })	# define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
// typeof() est une extension de gcc, mais est présent sur d'autres compilateurs	// typeof() est une extension de gcc, mais est prÃ©sent sur d'autres compilateurs
// comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible	// comme Sun Studio. Dans le cas oÃ¹ typeof() n'existe pas, il est possible
// d'utiliser la macro suivante, mais elle possède un effet de bord dû à	// d'utiliser la macro suivante, mais elle possÃ¨de un effet de bord dÃ» Ã
// l'évaluation multiple de l'argument.	// l'Ã©valuation multiple de l'argument.
#else	#else
# define abs(i) (((i) >= 0) ? (i) : (-i))	# define abs(i) (((i) >= 0) ? (i) : (-i))
#endif	#endif

#define BUG(b, ...) \
do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
(int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
__VA_ARGS__; fflush(stdout); \
pthread_kill(pthread_self(), SIGBUS); }} while(0)

#define NOTICE(m) \	#define NOTICE(m) \
do \	do \
{ \	{ \
Line 294 typedef unsigned char t_8_bits;	Line 636 typedef unsigned char t_8_bits;

#ifdef __GLIBC__	#ifdef __GLIBC__
#include <execinfo.h>	#include <execinfo.h>
	#define __BACKTRACE
#define BACKTRACE(n) \	#define BACKTRACE(n) \
do \	do \
{ \	{ \
Line 309 typedef unsigned char t_8_bits;	Line 652 typedef unsigned char t_8_bits;
if (appels != NULL) \	if (appels != NULL) \
{ \	{ \
for(i = 0; i < nb; i++) \	for(i = 0; i < nb; i++) \
uprintf("%s\n", appels[i]); \	uprintf(" %s\n", appels[i]); \
free(appels); \	free(appels); \
} \	} \
else \	else \
Line 322 typedef unsigned char t_8_bits;	Line 665 typedef unsigned char t_8_bits;
#define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")	#define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
#endif	#endif

	#ifdef __BACKTRACE
	# define BUG(b, ...) \
	do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
	(int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
	__VA_ARGS__; fflush(stdout); \
	BACKTRACE(64); \
	pthread_kill(pthread_self(), SIGBUS); }} while(0)
	#else
	# define BUG(b, ...) \
	do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
	(int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
	__VA_ARGS__; fflush(stdout); \
	pthread_kill(pthread_self(), SIGBUS); }} while(0)
	#endif


/*	/*
================================================================================	================================================================================
Line 330 typedef unsigned char t_8_bits;	Line 688 typedef unsigned char t_8_bits;
*/	*/

#ifdef DEBUG_MEMOIRE	#ifdef DEBUG_MEMOIRE
	void analyse_post_mortem();
void debug_memoire_ajout(size_t taille, const unsigned char fonction,	void debug_memoire_ajout(size_t taille, const unsigned char fonction,
unsigned long ligne, const unsigned char *argument);	unsigned long ligne, const unsigned char *argument);
	void debug_memoire_initialisation();
void debug_memoire_modification(void pointeur, size_t taille,	void debug_memoire_modification(void pointeur, size_t taille,
const unsigned char *fonction, unsigned long ligne,	const unsigned char *fonction, unsigned long ligne,
const unsigned char *argument);	const unsigned char *argument);
void debug_memoire_retrait(void *ptr);	void debug_memoire_retrait(void *ptr);
	void debug_memoire_verification();

	pid_t debug_fork();

#define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)	#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, \	#define realloc(s, t) debug_memoire_modification(s, t, \
__FUNCTION__, __LINE__, #t)	__FUNCTION__, __LINE__, #t)
	#define fork() debug_fork()
#endif	#endif

#ifdef DEBUG_RETURN	#ifdef DEBUG_RETURN
Line 363 void debug_memoire_retrait(void *ptr);	Line 727 void debug_memoire_retrait(void *ptr);
pthread_mutex_unlock(mutex)	pthread_mutex_unlock(mutex)
#endif	#endif

#ifdef DEBUG_SEMAPHORES
#define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
uprintf("[%d-%llu] Semaphore %s (%p) "\
"waiting at %s() " \
"line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); })
#define sem_post(a) ({ int value; sem_getvalue(a, &value); \
uprintf("[%d-%llu] Semaphore %s (%p) "\
"posting at %s() " \
"line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
#a, a, __FUNCTION__, __LINE__), fflush(stdout); \
if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); })
#define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
#endif

#ifdef DEBUG_MALLOC
#define malloc(taille) ({ size_t s = taille; void *p; \
p = malloc(taille); if (p != NULL) memset(p, 0, s); \
/*uprintf("[%d-%llu] Allocating %p (%d bytes) at %s() line #%d\n", \
(int) getpid(), (unsigned long long) pthread_self(), p, \
(int) s, __FUNCTION__, __LINE__); fflush(stdout); */ p; })
#endif

#ifdef DEBUG_FREE
#define free(ptr) ({ void *p = ptr; \
/*uprintf("[%d-%llu] Freeing %p (%d bytes) at %s() line #%d\n", \
(int) getpid(), (unsigned long long) pthread_self(), p, \
(int) sizeof(p), __FUNCTION__, __LINE__); fflush(stdout); */ \
if (p != NULL) memset(p, 0, sizeof(p)); free(p); })
#endif

/*	/*
================================================================================	================================================================================
Line 414 void debug_memoire_retrait(void *ptr);	Line 746 void debug_memoire_retrait(void *ptr);
#define d_absence_erreur ((logical1) d_faux)	#define d_absence_erreur ((logical1) d_faux)
#define d_erreur ((logical1) d_vrai)	#define d_erreur ((logical1) d_vrai)

#define d_code_fin_chaine '\0'	#define d_code_fin_chaine '\0'
#define d_code_espace ' '	#define d_code_espace ' '
#define d_code_retour_chariot '\n'	#define d_code_retour_chariot '\n'
#define d_code_tabulation '\t'	#define d_code_tabulation '\t'
	#define d_longueur_maximale_instruction 16

#define d_INT "integer"	#define d_INT "integer"
#define d_REL "real"	#define d_REL "real"
Line 445 void debug_memoire_retrait(void *ptr);	Line 778 void debug_memoire_retrait(void *ptr);

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Paramètres du système	ParamÃ¨tres du systÃ¨me
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 464 void debug_memoire_retrait(void *ptr);	Line 797 void debug_memoire_retrait(void *ptr);

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Erreurs système	Erreurs systÃ¨me
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#define __erreur { uprintf("%s() / %d\n", __FUNCTION__, __LINE__); } while(0)	#ifdef DEBUG_ERREURS
	# ifdef MESSAGES
	# define __erreur(i) i
	# define __erreur_(i) i
	# else
	# undef _ERREURS_VARIABLES
	# ifdef _ERREURS_VARIABLES
	# define __erreur_(i) __erreur(i)
	# else
	# define __erreur_(i) i
	# endif
	# define __erreur(i) ({ if (strstr(__FUNCTION__, "recherche_variable") \
	== NULL) ufprintf(stderr, \
	"ERROR %d AT %s() FROM %s LINE %d\n", \
	i, __FUNCTION__, __FILE__, __LINE__); i; })
	# endif
	#else
	# define __erreur(i) i
	# define __erreur_(i) i
	#endif


// -1 : erreur provoquée par une bibliothèque externe	// -1 : erreur provoquÃ©e par une bibliothÃ¨que externe
#ifndef RPLARGS	#ifndef RPLARGS
# define d_es 2000	# define d_es 2000
# define d_es_allocation_memoire 2001	# define d_es_allocation_memoire __erreur(2001)
# define d_es_variable_introuvable 2002	# define d_es_variable_introuvable __erreur_(2002)
# define d_es_pile_vide 2003	# define d_es_pile_vide __erreur(2003)
# define d_es_end_incoherent 2004	# define d_es_end_incoherent __erreur(2004)
# define d_es_peripherique_stdin 2005	# define d_es_peripherique_stdin __erreur(2005)
# define d_es_erreur_fichier 2006	# define d_es_erreur_fichier __erreur(2006)
# define d_es_execution_bibliotheque 2007	# define d_es_execution_bibliotheque __erreur(2007)
# define d_es_signal 2008	# define d_es_signal __erreur(2008)
# define d_es_processus 2009	# define d_es_processus __erreur(2009)
# define d_es_pile_operationnelle_vide 2010	# define d_es_pile_operationnelle_vide __erreur(2010)
# define d_es_nombre_max_descripteurs 2011	# define d_es_nombre_max_descripteurs __erreur(2011)
# define d_es_interruption_invalide 2012	# define d_es_interruption_invalide __erreur(2012)
# define d_es_contexte 2013	# define d_es_contexte __erreur(2013)
# define d_es_somme_controle 2014	# define d_es_somme_controle __erreur(2014)
	# define d_es_semaphore __erreur(2015)
	# define d_es_mutex_acquis_autre_thread __erreur(2016)
#endif	#endif

/*	/*
Line 497 void debug_memoire_retrait(void *ptr);	Line 852 void debug_memoire_retrait(void *ptr);

#ifndef RPLARGS	#ifndef RPLARGS
# define d_ep 1000	# define d_ep 1000
# define d_ep_division_par_zero 1001	# define d_ep_division_par_zero __erreur(1001)
# define d_ep_matrice_non_inversible 1002	# define d_ep_matrice_non_inversible __erreur(1002)
# define d_ep_resultat_indefini 1003	# define d_ep_resultat_indefini __erreur(1003)
# define d_ep_underflow 1004	# define d_ep_underflow __erreur(1004)
# define d_ep_overflow 1005	# define d_ep_overflow __erreur(1005)
# define d_ep_domaine_definition 1006	# define d_ep_domaine_definition __erreur(1006)
# define d_ep_perte_precision 1007	# define d_ep_perte_precision __erreur(1007)
# define d_ep_decomposition_QR 1008	# define d_ep_decomposition_QR __erreur(1008)
# define d_ep_matrice_non_definie_positive 1009	# define d_ep_matrice_non_definie_positive __erreur(1009)
# define d_ep_decomposition_QZ 1010	# define d_ep_decomposition_QZ __erreur(1010)
# define d_ep_decomposition_SVD 1011	# define d_ep_decomposition_SVD __erreur(1011)
#endif	#endif

/*	/*
Line 518 void debug_memoire_retrait(void *ptr);	Line 873 void debug_memoire_retrait(void *ptr);

#ifndef RPLARGS	#ifndef RPLARGS
# define d_ec 3000	# define d_ec 3000
# define d_ec_niveau_definition_negatif 3001	# define d_ec_niveau_definition_negatif __erreur(3001)
# define d_ec_nom_definition_invalide 3002	# define d_ec_nom_definition_invalide __erreur(3002)
# define d_ec_erreur_boucle_definie 3003	# define d_ec_erreur_boucle_definie __erreur(3003)
# define d_ec_erreur_instruction_end 3004	# define d_ec_erreur_instruction_end __erreur(3004)
# define d_ec_erreur_instruction_until 3005	# define d_ec_erreur_instruction_until __erreur(3005)
# define d_ec_source_incoherent 3006	# define d_ec_source_incoherent __erreur(3006)
# define d_ec_erreur_instruction_while 3007	# define d_ec_erreur_instruction_while __erreur(3007)
# define d_ec_erreur_instruction_then 3008	# define d_ec_erreur_instruction_then __erreur(3008)
# define d_ec_erreur_instruction_else 3009	# define d_ec_erreur_instruction_else __erreur(3009)
# define d_ec_erreur_instruction_elseif 3010	# define d_ec_erreur_instruction_elseif __erreur(3010)
# define d_ec_erreur_instruction_select 3011	# define d_ec_erreur_instruction_select __erreur(3011)
# define d_ec_erreur_instruction_case 3012	# define d_ec_erreur_instruction_case __erreur(3012)
#endif	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Erreurs à l'exécution	Erreurs Ã l'exÃ©cution
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

// -1 : erreur provoquée par une bibliothèque externe	// -1 : erreur provoquÃ©e par une bibliothÃ¨que externe
#ifndef RPLARGS	#ifndef RPLARGS
# define d_ex 0	# define d_ex 0
# define d_ex_pile_vide 1	# define d_ex_pile_vide __erreur(1)
# define d_ex_manque_argument 2	# define d_ex_manque_argument __erreur(2)
# define d_ex_argument_invalide 3	# define d_ex_argument_invalide __erreur(3)
# define d_ex_erreur_type_argument 4	# define d_ex_erreur_type_argument __erreur(4)
# define d_ex_nom_reserve 5	# define d_ex_nom_reserve __erreur(5)
# define d_ex_nombre_arguments 6	# define d_ex_nombre_arguments __erreur(6)
# define d_ex_dimensions_invalides 7	# define d_ex_dimensions_invalides __erreur(7)
# define d_ex_expression_invalide 8	# define d_ex_expression_invalide __erreur(8)
# define d_ex_absence_graphique_courant 9	# define d_ex_absence_graphique_courant __erreur(9)
# define d_ex_erreur_traitement_condition 10	# define d_ex_erreur_traitement_condition __erreur(10)
# define d_ex_erreur_traitement_boucle 11	# define d_ex_erreur_traitement_boucle __erreur(11)
# define d_ex_variable_non_definie 12	# define d_ex_variable_non_definie __erreur_(12)
# define d_ex_drapeau_inexistant 13	# define d_ex_drapeau_inexistant __erreur(13)
# define d_ex_nom_invalide 14	# define d_ex_nom_invalide __erreur(14)
# define d_ex_element_inexistant 15	# define d_ex_element_inexistant __erreur(15)
# define d_ex_absence_variable 16	# define d_ex_absence_variable __erreur(16)
# define d_ex_erreur_evaluation 17	# define d_ex_erreur_evaluation __erreur(17)
# define d_ex_semaphore 18	# define d_ex_semaphore __erreur(18)
# define d_ex_longueur_fft 19	# define d_ex_longueur_fft __erreur(19)
# define d_ex_queue_impression 20	# define d_ex_queue_impression __erreur(20)
# define d_ex_type_trace_invalide 21	# define d_ex_type_trace_invalide __erreur(21)
# define d_ex_erreur_fichier 22	# define d_ex_erreur_fichier __erreur(22)
# define d_ex_absence_equation 23	# define d_ex_absence_equation __erreur(23)
# define d_ex_erreur_bibliotheque 24	# define d_ex_erreur_bibliotheque __erreur(24)
# define d_ex_execution_bibliotheque 25	# define d_ex_execution_bibliotheque __erreur(25)
# define d_ex_stop 26	# define d_ex_stop __erreur(26)
# define d_ex_matrice_statistique_invalide 27	# define d_ex_matrice_statistique_invalide __erreur(27)
# define d_ex_dimensions_matrice_statistique 28	# define d_ex_dimensions_matrice_statistique __erreur(28)
# define d_ex_absence_observations 29	# define d_ex_absence_observations __erreur(29)
# define d_ex_statistiques_echantillon 30	# define d_ex_statistiques_echantillon __erreur(30)
# define d_ex_observations_inexistantes 31	# define d_ex_observations_inexistantes __erreur(31)
# define d_ex_syntaxe 32	# define d_ex_syntaxe __erreur(32)
# define d_ex_cycle_hors_boucle 33	# define d_ex_cycle_hors_boucle __erreur(33)
# define d_ex_conversion_unite 34	# define d_ex_conversion_unite __erreur(34)
# define d_ex_erreur_parametre_fichier 35	# define d_ex_erreur_parametre_fichier __erreur(35)
# define d_ex_erreur_acces_fichier 36	# define d_ex_erreur_acces_fichier __erreur(36)
# define d_ex_erreur_requete_fichier 37	# define d_ex_erreur_requete_fichier __erreur(37)
# define d_ex_erreur_format_fichier 38	# define d_ex_erreur_format_fichier __erreur(38)
# define d_ex_fichier_verrouille 39	# define d_ex_fichier_verrouille __erreur(39)
# define d_ex_verrou_indefini 40	# define d_ex_verrou_indefini __erreur(40)
# define d_ex_fin_de_fichier_atteinte 41	# define d_ex_fin_de_fichier_atteinte __erreur(41)
# define d_ex_debut_de_fichier_atteint 42	# define d_ex_debut_de_fichier_atteint __erreur(42)
# define d_ex_erreur_type_fichier 43	# define d_ex_erreur_type_fichier __erreur(43)
# define d_ex_fichier_vide 44	# define d_ex_fichier_vide __erreur(44)
# define d_ex_dimensions_differentes 45	# define d_ex_dimensions_differentes __erreur(45)
# define d_ex_routines_mathematiques 46	# define d_ex_routines_mathematiques __erreur(46)
# define d_ex_exit_hors_boucle 47	# define d_ex_exit_hors_boucle __erreur(47)
# define d_ex_longueur_dft 48	# define d_ex_longueur_dft __erreur(48)
# define d_ex_contexte 49	# define d_ex_contexte __erreur(49)
# define d_ex_processus 50	# define d_ex_processus __erreur(50)
# define d_ex_image_processus 51	# define d_ex_image_processus __erreur(51)
# define d_ex_erreur_sql 52	# define d_ex_erreur_sql __erreur(52)
# define d_ex_variable_verrouillee 53	# define d_ex_variable_verrouillee __erreur(53)
# define d_ex_variable_volatile 54	# define d_ex_variable_volatile __erreur(54)
# define d_ex_erreur_processus 55	# define d_ex_erreur_processus __erreur(55)
# define d_ex_erreur_impression 56	# define d_ex_erreur_impression __erreur(56)
# define d_ex_nombre_arguments_fonction 57	# define d_ex_nombre_arguments_fonction __erreur(57)
# define d_ex_fonction_indisponible 58	# define d_ex_fonction_indisponible __erreur(58)
# define d_ex_bibliotheque_chargee 59	# define d_ex_bibliotheque_chargee __erreur(59)
# define d_ex_aucun_symbole 60	# define d_ex_aucun_symbole __erreur(60)
# define d_ex_definition_ambigue 61	# define d_ex_definition_ambigue __erreur(61)
# define d_ex_fichier_hors_contexte 62	# define d_ex_fichier_hors_contexte __erreur(62)
# define d_ex_socket_en_ecoute 63	# define d_ex_socket_en_ecoute __erreur(63)
# define d_ex_interruption_invalide 64	# define d_ex_interruption_invalide __erreur(64)
# define d_ex_erreur_transcodage 65	# define d_ex_erreur_transcodage __erreur(65)
# define d_ex_absence_processus_pere 66	# define d_ex_absence_processus_pere __erreur(66)
# define d_ex_creation_variable 67	# define d_ex_creation_variable __erreur(67)
# define d_ex_fusible 68	# define d_ex_fusible __erreur(68)
# define d_ex_iswi_hors_interruption 69	# define d_ex_iswi_hors_interruption __erreur(69)
# define d_ex_daemon 70	# define d_ex_daemon __erreur(70)
# define d_ex_mutex 71	# define d_ex_mutex __erreur(71)
# define d_ex_variable_statique_partagee 72	# define d_ex_variable_statique_partagee __erreur(72)
# define d_ex_variable_partagee 73	# define d_ex_variable_partagee __erreur(73)
# define d_ex_graphique_memorise 74	# define d_ex_graphique_memorise __erreur(74)
# define d_ex_matrice_non_diagonale 75	# define d_ex_matrice_non_diagonale __erreur(75)
# define d_ex_locales 76	# define d_ex_locales __erreur(76)
# define d_ex_representation 77	# define d_ex_representation __erreur(77)
# define d_ex_erreur_profilage 78	# define d_ex_erreur_profilage __erreur(78)
#endif	# define d_ex_enregistrement_inexistant __erreur(79)
	# define d_ex_clef_inexistante __erreur(80)
/*	# define d_ex_nom_implicite __erreur(81)
--------------------------------------------------------------------------------	# define d_ex_version_bibliotheque __erreur(82)
Erreurs de la ligne de commande	# define d_ex_creation_variable_globale __erreur(83)
--------------------------------------------------------------------------------	# define d_ex_erreur_interne_rplcas __erreur(84)
*/	# define d_ex_fichier_corrompu __erreur(85)
	# define d_ex_mutex_acquis_autre_thread __erreur(86)
#ifndef RPLARGS	# define d_ex_expression_reguliere __erreur(87)
# define d_os 4000	# define d_ex_instruction_indisponible __erreur(88)
# define d_os_ligne_de_commande 4001	# define d_ex_chiffrement __erreur(89)
# define d_os_fichier_introuvable 4002	# define d_ex_chiffrement_indisponible __erreur(90)
	# define d_ex_longueur_clef_chiffrement __erreur(91)
	# define d_ex_taille_message __erreur(92)
#endif	#endif


/*	/*
================================================================================	================================================================================
STRUCTURES	STRUCTURES
Line 645 void debug_memoire_retrait(void *ptr);	Line 1003 void debug_memoire_retrait(void *ptr);
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	#ifdef MIN
	# undef MIN
	#endif

	#ifdef MAX
	# undef MAX
	#endif

	#define ADR __RPL_ADR
	#define ALG __RPL_ALG
	#define BIN __RPL_BIN
	#define CHN __RPL_CHN
	#define CPL __RPL_CPL
	#define FCH __RPL_FCH
	#define FCT __RPL_FCT
	#define INT __RPL_INT
	#define LST __RPL_LST
	#define MCX __RPL_MCX
	#define MIN __RPL_MIN
	#define MRL __RPL_MRL
	#define MTX __RPL_MTX
	#define NOM __RPL_NOM
	#define NON __RPL_NON
	#define PRC __RPL_PRC
	#define REL __RPL_REL
	#define RPN __RPL_RPN
	#define SCK __RPL_SCK
	#define SLB __RPL_SLB
	#define SPH __RPL_SPH
	#define SQL __RPL_SQL
	#define TBL __RPL_TBL
	#define VCX __RPL_VCX
	#define VIN __RPL_VIN
	#define VRL __RPL_VRL

	enum t_rplcas_commandes { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };

enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,	enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,	MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
SLB, SPH, SQL, TBL, VCX, VIN, VRL };	SLB, SPH, SQL, TBL, VCX, VIN, VRL };

/*	/*
ADR : adresse sur 32 bits (au moins) non signés (unsigned long)	ADR : adresse sur 64 bits signÃ©s.
Adresse d'une définition à interpréter.	Adresse d'une dÃ©finition Ã interprÃ©ter.

ALG : expression algébrique (struct_liste_chainee *)	ALG : expression algÃ©brique (struct_liste_chainee *)
La liste chaînée contient la définition convertie en notation	La liste chaÃ®nÃ©e contient la dÃ©finition convertie en notation
polonaise inversée. Ce type diffère du type 'RPN' au niveau	polonaise inversÃ©e. Ce type diffÃ¨re du type 'RPN' au niveau
du format de sortie (notation algébrique).	du format de sortie (notation algÃ©brique).

BIN : entier binaire sur 64 bits (unsigned integer8 *)	BIN : entier binaire sur 64 bits (unsigned integer8 *)
Sans objet.	Sans objet.
Line 671 enum t_type { ADR = 0, ALG, BIN, CHN, C	Line 1066 enum t_type { ADR = 0, ALG, BIN, CHN, C

FCH : descripteur de fichier (struct_fichier *).	FCH : descripteur de fichier (struct_fichier *).

FCT : déclaration d'une fonction et de son nombre d'arguments	FCT : dÃ©claration d'une fonction et de son nombre d'arguments
(struct_fonction *). Ce type n'est nécessaire que dans le	(struct_fonction *). Ce type n'est nÃ©cessaire que dans le
traitement des types 'ALG' et 'RPN'.	traitement des types 'ALG' et 'RPN'.

INT : entier sur 64 bits (integer8, integer8 )	INT : entier sur 64 bits (integer8, integer8 )
Line 680 enum t_type { ADR = 0, ALG, BIN, CHN, C	Line 1075 enum t_type { ADR = 0, ALG, BIN, CHN, C
Type C/Fortran : integer8	Type C/Fortran : integer8

LST : liste (struct_liste_chainee *)	LST : liste (struct_liste_chainee *)
Les objets sont enregistrés sous forme de liste chaînée récursive.	Les objets sont enregistrÃ©s sous forme de liste chaÃ®nÃ©e rÃ©cursive.
Cela permet de traiter des tableaux de données hétérogènes de	Cela permet de traiter des tableaux de donnÃ©es hÃ©tÃ©rogÃ¨nes de
grandes dimensions. Le nombre de dimensions maximal est fixé par	grandes dimensions. Le nombre de dimensions maximal est fixÃ© par
la mémoire de la station.	la mÃ©moire de la station.

MCX : matrice de complexes (struct_matrice *)	MCX : matrice de complexes (struct_matrice *)
Sans objet.	Sans objet.
Line 707 enum t_type { ADR = 0, ALG, BIN, CHN, C	Line 1102 enum t_type { ADR = 0, ALG, BIN, CHN, C
Sans objet.	Sans objet.

RPN : definition (struct_liste_chainee *)	RPN : definition (struct_liste_chainee *)
Ce type diffère du type 'ALG' au niveau du format de sortie	Ce type diffÃ¨re du type 'ALG' au niveau du format de sortie
(notation polonaise inversée).	(notation polonaise inversÃ©e).

SCK : socket (struct_socket *)	SCK : socket (struct_socket *)

SLB : bibliothèque dynamique partagée (struct_bibliotheque *)	SLB : bibliothÃ¨que dynamique partagÃ©e (struct_bibliotheque *)
Sans objet.	Sans objet.

SPH : sémaphore nommé (struct_semaphore *)	SPH : sÃ©maphore nommÃ© (struct_semaphore *)

SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)	SQL : connecteur sur une base de donnÃ©es SQL (struct_connecteur_sql *)

TBL : tableau multidimensionnel d'objets (struct_tableau *).	TBL : tableau multidimensionnel d'objets (struct_tableau *).

Line 752 typedef struct objet	Line 1147 typedef struct objet
#ifndef RPLARGS	#ifndef RPLARGS
typedef struct fichier	typedef struct fichier
{	{
unsigned long descripteur;	int descripteur;

unsigned char acces; /* S/D/I */	unsigned char acces; /* S/D/I */
unsigned char binaire; /* Y/N/F */	unsigned char binaire; /* Y/N/F */
Line 780 typedef struct fichier	Line 1175 typedef struct fichier
typedef struct rpl_mutex	typedef struct rpl_mutex
{	{
pthread_mutex_t mutex;	pthread_mutex_t mutex;
	pthread_t tid;
} struct_mutex;	} struct_mutex;
#endif	#endif


/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure sémaphore	Structure sÃ©maphore
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 818 typedef struct marque	Line 1214 typedef struct marque

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure bibliothèque	Structure bibliothÃ¨que
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 844 typedef struct bibliotheque	Line 1240 typedef struct bibliotheque
#ifndef RPLARGS	#ifndef RPLARGS
typedef struct descripteur_fichier	typedef struct descripteur_fichier
{	{
unsigned long identifiant;	int identifiant;

unsigned char effacement;	unsigned char effacement;
	unsigned char type; // C (file ) ou S (sqlite )
unsigned char *nom;	unsigned char *nom;

pid_t pid;	pid_t pid;
pthread_t tid;	pthread_t tid;

file *descripteur;	union
	{
	file *descripteur_c;
	sqlite3 *descripteur_sqlite;
	};
} struct_descripteur_fichier;	} struct_descripteur_fichier;
#endif	#endif

Line 885 typedef struct connecteur_sql	Line 1286 typedef struct connecteur_sql
# ifdef POSTGRESQL_SUPPORT	# ifdef POSTGRESQL_SUPPORT
PGconn *postgresql;	PGconn *postgresql;
# endif	# endif
	sqlite3 *sqlite;
} descripteur;	} descripteur;
} struct_connecteur_sql;	} struct_connecteur_sql;
#endif	#endif
Line 898 typedef struct connecteur_sql	Line 1300 typedef struct connecteur_sql
"POSTGRESQL") == 0) \	"POSTGRESQL") == 0) \
postgresqlclose((((struct_connecteur_sql ) (*s_objet).objet)) \	postgresqlclose((((struct_connecteur_sql ) (*s_objet).objet)) \
.descripteur); \	.descripteur); \
	else if (strcmp((((struct_connecteur_sql ) (*s_objet).objet)).type, \
	"SQLITE") == 0) \
	sqlite3_close((((struct_connecteur_sql ) (*s_objet).objet)) \
	.descripteur.sqlite); \
else \	else \
BUG(1, uprintf("SQL type '%s' not allowed!", \	BUG(1, uprintf("SQL type '%s' not allowed!", \
(((struct_connecteur_sql ) (*s_objet).objet)).type));	(((struct_connecteur_sql ) (*s_objet).objet)).type));
Line 933 typedef struct socket	Line 1339 typedef struct socket

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure liste chaînee	Structure liste chaÃ®nee
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 947 typedef struct liste_chainee	Line 1353 typedef struct liste_chainee

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
	Structure de gestion des signaux en provenance de rplsignal
	--------------------------------------------------------------------------------
	*/

	#define d_NOMBRE_SIGNAUX 64

	typedef struct gestion_signaux
	{
	unsigned char masque_signaux[d_NOMBRE_SIGNAUX];

	/*
	* 'I' : signal ignorÃ©
	* 'Q' : signal mis en queue pour un traitement ultÃ©rieur
	* 'N' : traitement normal du signal
	*/

	integer8 queue_signaux[d_NOMBRE_SIGNAUX];
	integer8 nombre_signaux_en_queue;
	struct_objet *corps_signaux[d_NOMBRE_SIGNAUX];

	pthread_mutex_t mutex;
	} struct_gestion_signaux;

	#ifndef MAIN_RPL
	# define __STATIC_GESTION_SIGNAUX__
	#else
	# define __STATIC_GESTION_SIGNAUX__ = { .mutex = PTHREAD_MUTEX_INITIALIZER }
	#endif

	__EXTERN__ volatile struct_gestion_signaux signaux_externes
	__STATIC_GESTION_SIGNAUX__;


	/*
	--------------------------------------------------------------------------------
Structure liste profilage	Structure liste profilage
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
Line 972 typedef struct liste_profilage2	Line 1413 typedef struct liste_profilage2

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure contenant les fichiers graphiques (liste chaînée)	Structure contenant les fichiers graphiques (liste chaÃ®nÃ©e)
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 1004 typedef struct nom	Line 1445 typedef struct nom
{	{
unsigned char *nom;	unsigned char *nom;
logical1 symbole; /* d_vrai/d_faux */	logical1 symbole; /* d_vrai/d_faux */
// symbole == d_vrai signifie que le nom a été introduit dans un	// symbole == d_vrai signifie que le nom a Ã©tÃ© introduit dans un
// calcul sans les apostrophes.	// calcul sans les apostrophes.
} struct_nom;	} struct_nom;

Line 1029 typedef struct descripteur_thread	Line 1470 typedef struct descripteur_thread
pthread_t thread_pere;	pthread_t thread_pere;

pthread_mutex_t mutex;	pthread_mutex_t mutex;
	pthread_mutex_t mutex_nombre_references;

volatile logical1 thread_actif;	volatile logical1 thread_actif;

int pipe_erreurs[2];	int pipe_erreurs[2];
Line 1036 typedef struct descripteur_thread	Line 1479 typedef struct descripteur_thread
int pipe_injections[2];	int pipe_injections[2];
int pipe_nombre_injections[2];	int pipe_nombre_injections[2];
int pipe_interruptions[2];	int pipe_interruptions[2];
int pipe_nombre_objets_attente[2];	// pipe_nombre_elements_attente == 0 => initialisation ou terminaison
int pipe_nombre_interruptions_attente[2];	// pipe_nombre_elements_attente == 1 => objet en attente
	// pipe_nombre_elements_attente == 2 => interruption en attente
	int pipe_nombre_elements_attente[2];
int pipe_acquittement[2];	int pipe_acquittement[2];

volatile integer8 nombre_objets_dans_pipe;	volatile integer8 nombre_objets_dans_pipe;
Line 1046 typedef struct descripteur_thread	Line 1491 typedef struct descripteur_thread
logical1 processus_detache;	logical1 processus_detache;
logical1 destruction_objet;	logical1 destruction_objet;

sigset_t oldset;
sigset_t set;

volatile signed long nombre_references;	volatile signed long nombre_references;
} struct_descripteur_thread;	} struct_descripteur_thread;

Line 1070 typedef struct liste_pile_systeme	Line 1512 typedef struct liste_pile_systeme
{	{
struct liste_pile_systeme *suivant;	struct liste_pile_systeme *suivant;

struct_liste_chainee *pointeur_objet_retour;

struct_objet *indice_boucle;	struct_objet *indice_boucle;
struct_objet *limite_indice_boucle;	struct_objet *limite_indice_boucle;
struct_objet *objet_de_test;	struct_objet *objet_de_test;
Line 1087 typedef struct liste_pile_systeme	Line 1527 typedef struct liste_pile_systeme
clause :	clause :
I : IF	I : IF
R : IFERR	R : IFERR
X : IFERR indiquant la présence d'une erreur.	X : IFERR indiquant la prÃ©sence d'une erreur.
T : THEN	T : THEN
E : ELSE	E : ELSE
Z : traitement en cours de ELSE	Z : traitement en cours de ELSE
Line 1096 typedef struct liste_pile_systeme	Line 1536 typedef struct liste_pile_systeme
W : WHILE	W : WHILE
M : WHILE avec une clause fausse.	M : WHILE avec une clause fausse.
S : SELECT	S : SELECT
K : aucun cas CASE n'a encore été traité.	K : aucun cas CASE n'a encore Ã©tÃ© traitÃ©.
C : au moins un cas de SELECT...CASE a été traité.	C : au moins un cas de SELECT...CASE a Ã©tÃ© traitÃ©.
Q : traitement en cours d'un cas CASE.	Q : traitement en cours d'un cas CASE.
F : traitement du cas DEFAULT	F : traitement du cas DEFAULT
*/	*/
Line 1108 typedef struct liste_pile_systeme	Line 1548 typedef struct liste_pile_systeme
unsigned char type_cloture;	unsigned char type_cloture;

/*	/*
type clôture :	type clÃ´ture :
C CASE : END termine un test SELECT/CASE/THEN/END/DEFAULT/END.	C SELECT : END termine un test SELECT/DEFAULT/END.
D DO : END termine une boucle DO/UNTIL/END.	D DO : END termine une boucle DO/UNTIL/END.
I IF : END termine un test IF/THEN (ELSE)/END.	I IF : END termine un test IF/THEN (ELSE)/END.
J IFERR : END termine un test IFERR/THEN (ELSE)/END.	J IFERR : END termine un test IFERR/THEN (ELSE)/END.
W WHILE : END termine une boucle WHILE/REPEAT/END.	K CASE : END termine un test CASE/THEN/END
	W WHILE : END termine une boucle WHILE/REPEAT/END.
F FOR : NEXT ou STEP termine une boucle avec compteur.	Q CRITICAL : END termine une section critique CRITICAL/END
S START : NEXT ou STEP termine une boucle sans compteur.
L LOOP : boucle utilisé dans le traitement de l'instruction RETURN.	F FOR : NEXT ou STEP termine une boucle avec compteur.
Elle correspond à une boucle FOR ou START mais sans son	S START : NEXT ou STEP termine une boucle sans compteur.
	L LOOP : boucle utilisÃ© dans le traitement de l'instruction RETURN.
	Elle correspond Ã une boucle FOR ou START mais sans son
initialisation.	initialisation.
	A FORALL : NEXT termine une boucle sur un objet.
*/	*/

unsigned long adresse_retour;	integer8 adresse_retour;
unsigned long niveau_courant;	integer8 niveau_courant;
	struct_liste_chainee *pointeur_objet_retour;
} struct_liste_pile_systeme;	} struct_liste_pile_systeme;
#endif	#endif

Line 1137 typedef struct liste_pile_systeme	Line 1581 typedef struct liste_pile_systeme
#ifndef RPLARGS	#ifndef RPLARGS
typedef union position_variable	typedef union position_variable
{	{
unsigned long adresse;	integer8 adresse;
struct_objet *pointeur;	struct_objet *pointeur;
} union_position_variable;	} union_position_variable;

typedef struct variable	typedef struct variable
{	{
unsigned char *nom;	unsigned char *nom;
unsigned char origine;	unsigned char origine; // P(rogramme) ou E(valuation)

unsigned long niveau;	integer8 niveau;

union_position_variable variable_statique;	union_position_variable variable_statique;
union_position_variable variable_partagee;	union_position_variable variable_partagee;
Line 1160 typedef struct variable	Line 1604 typedef struct variable

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure variable partagée	Structure variable partagÃ©e
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 1171 typedef struct variable_partage	Line 1615 typedef struct variable_partage
unsigned char *nom;	unsigned char *nom;
unsigned char origine;	unsigned char origine;

unsigned long niveau;	integer8 niveau;

union_position_variable variable_partagee;	union_position_variable variable_partagee;

struct_objet *objet;	struct_objet *objet;
} struct_variable_partagee;

typedef struct table_variables_partagees
{
pthread_mutex_t mutex;

volatile struct_variable_partagee *table;

volatile unsigned long nombre_variables;	pthread_mutex_t mutex;
volatile unsigned long nombre_variables_allouees;	} struct_variable_partagee;

unsigned long position_variable;
} struct_table_variables_partagees;

#endif	#endif

Line 1205 typedef struct variable_statique	Line 1639 typedef struct variable_statique
unsigned char *nom;	unsigned char *nom;
unsigned char origine;	unsigned char origine;

// Position de création de la variable statique dans le programme ou dans	// Position de crÃ©ation de la variable statique dans le programme ou dans
// l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.	// l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.

unsigned long niveau;	integer8 niveau;

union_position_variable variable_statique;	union_position_variable variable_statique;

Line 1225 typedef struct variable_statique	Line 1659 typedef struct variable_statique

typedef struct vecteur	typedef struct vecteur
{	{
unsigned long taille;	integer8 taille;

unsigned char type; /* C (complex16), R (real8), I (integer8) /	unsigned char type; /* C (complex16), R (real8), I (integer8) /

Line 1241 typedef struct vecteur	Line 1675 typedef struct vecteur

typedef struct matrice	typedef struct matrice
{	{
unsigned long nombre_lignes;	integer8 nombre_lignes;
unsigned long nombre_colonnes;	integer8 nombre_colonnes;

unsigned char type; /* C (complex16), R (real8), I (integer8) /	unsigned char type; /* C (complex16), R (real8), I (integer8) /

Line 1258 typedef struct matrice	Line 1692 typedef struct matrice

typedef struct tableau	typedef struct tableau
{	{
unsigned long nombre_elements;	integer8 nombre_elements;

struct_objet **elements;	struct_objet **elements;
} struct_tableau;	} struct_tableau;
Line 1272 typedef struct tableau	Line 1706 typedef struct tableau

typedef struct arbre	typedef struct arbre
{	{
struct_objet *objet;	struct_liste_chainee *feuille;

unsigned long nombre_feuilles;	integer8 nombre_branches;
struct arbre **feuilles;	struct arbre **branches;
} struct_arbre;	} struct_arbre;


Line 1313 typedef struct rpl_arguments	Line 1747 typedef struct rpl_arguments
/* Traitement des erreurs */	/* Traitement des erreurs */

unsigned char *message_erreur;	unsigned char *message_erreur;
unsigned char type_erreur; /* S = système	unsigned char type_erreur; /* S = systÃ¨me
E = exécution */	E = exÃ©cution */
integer8 erreur;	integer8 erreur;

/* Traitement des messages d'aide */	/* Traitement des messages d'aide */
Line 1336 typedef struct rpl_arguments	Line 1770 typedef struct rpl_arguments
void *s_etat_processus;	void *s_etat_processus;
} struct_rpl_arguments;	} struct_rpl_arguments;

	/*
	--------------------------------------------------------------------------------
	Structure d'arbre des instructions intrinsÃ¨ques
	--------------------------------------------------------------------------------
	*/

	#ifndef RPLARGS
	typedef struct instruction
	{
	struct instruction **noeuds;
	void (feuille)(struct processus );
	} struct_instruction;
	#endif

	/*
	--------------------------------------------------------------------------------
	Structure d'arbre des variables globales et locales
	--------------------------------------------------------------------------------
	*/

	#ifndef RPLARGS
	typedef struct arbre_variables
	{
	unsigned int noeuds_utilises;
	// Nombre de noeuds utilisÃ©s dans le
	// tableau **noeuds
	signed int indice_tableau_pere;
	// Position de la structure dans le
	// tableau **noeuds du pÃ¨re

	struct arbre_variables *noeud_pere;
	struct arbre_variables **noeuds;

	struct liste_variables *feuille;
	struct liste_variables_statiques *feuille_statique;
	} struct_arbre_variables;

	typedef struct arbre_variables_partagees
	{
	unsigned int noeuds_utilises;
	// Nombre de noeuds utilisÃ©s dans le
	// tableau **noeuds
	signed int indice_tableau_pere;
	// Position de la structure dans le
	// tableau **noeuds du pÃ¨re

	struct arbre_variables_partagees *noeud_pere;
	struct arbre_variables_partagees **noeuds;

	struct liste_variables_partagees *feuille;

	pthread_mutex_t mutex_feuille;
	} struct_arbre_variables_partagees;

	#define INITIALISATION_MUTEX(mutex) \
	do { \
	pthread_mutexattr_t attributs_mutex; \
	pthread_mutexattr_init(&attributs_mutex); \
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); \
	pthread_mutex_init(&(mutex), &attributs_mutex); \
	pthread_mutexattr_destroy(&attributs_mutex); \
	} while(0)

	typedef struct tableau_variables
	{
	unsigned char origine;
	unsigned char *nom; // pointeur sur la struct_variable
	// rÃ©elle et non copie de la chaÃ®ne
	integer8 niveau;

	struct_objet *objet; // pointeur sur l'objet et non copie
	// de l'objet.

	logical1 variable_verrouillee;
	logical1 variable_masquee;
	pthread_mutex_t *mutex;
	union_position_variable variable_statique;
	union_position_variable variable_partagee;
	} struct_tableau_variables;

	// La liste des variables est une liste doublement chaÃ®nÃ©e et circulaire.
	typedef struct liste_variables
	{
	union
	{
	// Utilisation dans la gestion des variables
	struct_variable *variable;
	// Utilisation dans la pile systÃ¨me (variables par niveau)
	struct_liste_chainee *liste;
	};

	struct arbre_variables *noeud_pere;
	struct arbre_variables *noeud;
	struct liste_variables *suivant;
	struct liste_variables *precedent;
	} struct_liste_variables;

	// La liste des variables statiques et une liste double chaÃ®nÃ©e et non
	// circulaire.
	typedef struct liste_variables_statiques
	{
	struct liste_variables_statiques *suivant;
	struct liste_variables_statiques *precedent;
	struct liste_variables_statiques *reference;
	struct_arbre_variables *feuille;
	struct_variable_statique *variable;
	} struct_liste_variables_statiques;

	typedef struct liste_variables_partagees
	{
	struct liste_variables_partagees *suivant;
	struct liste_variables_partagees *precedent;
	struct liste_variables_partagees *reference;
	struct_arbre_variables_partagees *feuille;
	struct_variable_partagee *variable;
	pthread_t tid;
	pid_t pid;
	} struct_liste_variables_partagees;
	#endif


	/*
	--------------------------------------------------------------------------------
	Structure fonction
	--------------------------------------------------------------------------------
	*/

	#ifndef RPLARGS
	typedef struct fonction
	{
	unsigned char *nom_fonction;
	integer8 nombre_arguments;

	void (fonction)(struct processus );

	volatile struct_liste_chainee *prediction_saut;
	volatile logical1 prediction_execution;
	} struct_fonction;
	#endif


/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 1361 typedef struct processus	Line 1935 typedef struct processus
unsigned char autorisation_conversion_chaine; /Y/N/	unsigned char autorisation_conversion_chaine; /Y/N/
unsigned char autorisation_empilement_programme; /Y/N/	unsigned char autorisation_empilement_programme; /Y/N/
unsigned char autorisation_evaluation_nom; /Y/N/	unsigned char autorisation_evaluation_nom; /Y/N/
	unsigned char autorisation_nom_implicite; /Y/N/
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/
Line 1372 typedef struct processus	Line 1947 typedef struct processus
unsigned char mode_interactif; /Y/N/	unsigned char mode_interactif; /Y/N/
unsigned char mode_evaluation_expression; /Y/N/	unsigned char mode_evaluation_expression; /Y/N/
unsigned char traitement_cycle_exit; /N/E/C/	unsigned char traitement_cycle_exit; /N/E/C/
	unsigned char recherche_type; /Y/N/

unsigned long position_courante;	integer8 position_courante;
unsigned long longueur_definitions_chainees;	integer8 longueur_definitions_chainees;

/* Pointeurs sur les instructions */	/* Pointeurs sur les instructions */

int *pointeurs_caracteres;	int *pointeurs_caracteres;
int nombre_caracteres;	int nombre_caracteres;
struct instruction *arbre_instructions;	struct_instruction *arbre_instructions;

/* Requetes */	/* Requetes */

Line 1391 typedef struct processus	Line 1967 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 1411 typedef struct processus	Line 1987 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 1422 typedef struct processus	Line 1997 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];

# ifndef Cygwin	volatile int pointeur_signal_ecriture;
stack_t pile_signal;	volatile int pointeur_signal_lecture;
# else	volatile enum signaux_rpl signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
# define SA_ONSTACK 0	volatile logical1 demarrage_fils;
# define RTLD_LOCAL 0	volatile logical1 redemarrage_processus;
# endif

/* Contextes */	/* Contextes */

Line 1437 typedef struct processus	Line 2013 typedef struct processus

/* Variables */	/* Variables */

struct_variable *s_liste_variables;	// La liste des variables par niveau est doublement chaÃ®nÃ©e.
unsigned long nombre_variables;	// Ã€ tout moment, elle pointe sur le niveau le plus haut existant et
unsigned long nombre_variables_allouees;	// l_liste_variable_par_niveau->precedent renvoie la liste des
	// dÃ©finitions. l_liste_variable_par_niveau->precedent->precedent pointe
struct_variable_statique *s_liste_variables_statiques;	// sur la liste des variables globales.
unsigned long nombre_variables_statiques;	//
unsigned long nombre_variables_statiques_allouees;	// Ã€ l'initialisation :
	// l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
struct_table_variables_partagees	// l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
*s_liste_variables_partagees;
	struct_arbre_variables *s_arbre_variables;
unsigned long niveau_courant;	struct_liste_variables *l_liste_variables_par_niveau;
unsigned long niveau_initial;	struct_liste_variables_statiques
unsigned long position_variable_courante;	*l_liste_variables_statiques;
unsigned long position_variable_statique_courante;
	struct_arbre_variables_partagees
	**s_arbre_variables_partagees;
	struct_liste_variables_partagees
	**l_liste_variables_partagees;

	logical1 niveau_supprime;

	struct_variable *pointeur_variable_courante;
	struct_liste_variables *pointeur_feuille_courante;
	struct_variable_statique *pointeur_variable_statique_courante;
	struct_variable_partagee *pointeur_variable_partagee_courante;

	int *pointeurs_caracteres_variables;
	int nombre_caracteres_variables;

	integer8 niveau_courant;
	integer8 niveau_initial;

logical1 creation_variables_statiques;	logical1 creation_variables_statiques;
logical1 creation_variables_partagees;	logical1 creation_variables_partagees;
Line 1465 typedef struct processus	Line 2058 typedef struct processus

struct_liste_chainee *s_sockets;	struct_liste_chainee *s_sockets;

/* Connecteurs aux bases de données */	/* Connecteurs aux bases de donnÃ©es */

struct_liste_chainee *s_connecteurs_sql;	struct_liste_chainee *s_connecteurs_sql;

/* Bibliothèques dynamiques */	/* BibliothÃ¨ques dynamiques */

struct_liste_chainee *s_bibliotheques;	struct_liste_chainee *s_bibliotheques;
struct_instruction_externe *s_instructions_externes;	struct_instruction_externe *s_instructions_externes;
unsigned long nombre_instructions_externes;	integer8 nombre_instructions_externes;

/* Fichier d'impression */	/* Fichier d'impression */

Line 1623 typedef struct processus	Line 2216 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 1647 typedef struct processus	Line 2240 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 1661 typedef struct processus	Line 2254 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 1671 typedef struct processus	Line 2264 typedef struct processus
unsigned char masque_interruptions[d_NOMBRE_INTERRUPTIONS];	unsigned char masque_interruptions[d_NOMBRE_INTERRUPTIONS];

/*	/*
* 'I' : interruption ignorée	* 'I' : interruption ignorÃ©e
* 'Q' : interruption mise en queue pour un traitement ultérieur	* 'Q' : interruption mise en queue pour un traitement ultÃ©rieur
* 'N' : traitement normal de l'interruption	* 'N' : traitement normal de l'interruption
*/	*/

Line 1686 typedef struct processus	Line 2279 typedef struct processus

unsigned char traitement_interruption; /* Y/N */	unsigned char traitement_interruption; /* Y/N */
unsigned char traitement_interruptible; /* Y/N */	unsigned char traitement_interruptible; /* Y/N */
	unsigned char traitement_at_poke; /* Y/N */

	struct_objet *at_exit;
	struct_objet *at_poke;

/* Variables volatiles */	/* Variables volatiles */

volatile sig_atomic_t var_volatile_alarme;	volatile sig_atomic_t var_volatile_alarme;
// Traitement de ctrl+C et des arrêts brutaux	// Traitement de ctrl+C et des arrÃªts brutaux
volatile sig_atomic_t var_volatile_requete_arret;	volatile sig_atomic_t var_volatile_requete_arret;
// Traitement de ctrl+Z	// Traitement de ctrl+Z
volatile sig_atomic_t var_volatile_requete_arret2;	volatile sig_atomic_t var_volatile_requete_arret2;
volatile sig_atomic_t var_volatile_traitement_retarde_stop;	volatile sig_atomic_t var_volatile_traitement_retarde_stop;
volatile sig_atomic_t var_volatile_traitement_sigint;	volatile sig_atomic_t var_volatile_traitement_sigint;

	volatile sig_atomic_t var_volatile_processus_racine;
volatile sig_atomic_t var_volatile_processus_pere;	volatile sig_atomic_t var_volatile_processus_pere;
volatile sig_atomic_t var_volatile_recursivite;	volatile sig_atomic_t var_volatile_recursivite;

	volatile sig_atomic_t arret_depuis_abort;

volatile int var_volatile_exception_gsl;	volatile int var_volatile_exception_gsl;

/* Autres */	/* Autres */
Line 1709 typedef struct processus	Line 2309 typedef struct processus
gsl_rng *generateur_aleatoire;	gsl_rng *generateur_aleatoire;
const gsl_rng_type *type_generateur_aleatoire;	const gsl_rng_type *type_generateur_aleatoire;

	void *contexte_cas;

integer8 nombre_arguments;	integer8 nombre_arguments;

/*	/*
* Il s'agit du nombre d'arguments utilisé pour l'évaluation	* Il s'agit du nombre d'arguments utilisÃ© pour l'Ã©valuation
* des expressions algébriques.	* des expressions algÃ©briques.
* -1 : la fonction ne peut être dans un objet de type ALG.	* -1 : la fonction ne peut Ãªtre dans un objet de type ALG.
* -2 : nombre d'arguments inconnu	* -2 : nombre d'arguments inconnu
* 0 : la fonction doit apparaître en notation infixe	* 0 : la fonction doit apparaÃ®tre en notation infixe
* >0 : la fonction apparaît comme une fonction normale	* >0 : la fonction apparaÃ®t comme une fonction normale
*/	*/

logical1 lancement_interactif;	logical1 lancement_interactif;
Line 1727 typedef struct processus	Line 2329 typedef struct processus
unsigned char retour_routine_evaluation;	unsigned char retour_routine_evaluation;
unsigned char *localisation;	unsigned char *localisation;

unsigned long niveau_recursivite;	integer8 niveau_recursivite;

pid_t pid_processus_pere;	pid_t pid_processus_pere;
pthread_t tid_processus_pere;	pthread_t tid_processus_pere;
	pthread_t tid;

logical1 processus_detache;	logical1 processus_detache;

	enum t_type type_en_cours;

/* Profilage */	/* Profilage */

logical1 profilage;	logical1 profilage;
Line 1742 typedef struct processus	Line 2347 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_allocation;
pthread_mutex_t mutex;	pthread_mutex_t mutex_interruptions;
	pthread_mutex_t mutex_pile_processus;
	pthread_mutex_t mutex_signaux;

// Sémaphore autorisant les fork()	// Mutex autorisant les fork()
sem_t semaphore_fork;	sem_t __PTR__ semaphore_fork;

/* Mutexes */	/* Mutexes */

struct_liste_chainee *liste_mutexes;	struct_liste_chainee *liste_mutexes;
pthread_mutex_t protection_liste_mutexes;	pthread_mutex_t protection_liste_mutexes;
	unsigned int sections_critiques;

	/* Variable d'initialisation pour SCHED */

	logical1 initialisation_scheduler;

	/* Drapeau nÃ©cessaire Ã RESTART */

/* Gestion optimisée de la mémoire */	volatile logical1 requete_redemarrage;

	/* Gestion optimisÃ©e de la mÃ©moire */

double estimation_taille_pile_tampon;	double estimation_taille_pile_tampon;
unsigned long taille_pile_tampon;	integer8 taille_pile_tampon;
struct_liste_chainee *pile_tampon;	struct_liste_chainee *pile_tampon;

double estimation_taille_pile_systeme_tampon;	double estimation_taille_pile_systeme_tampon;
unsigned long taille_pile_systeme_tampon;	integer8 taille_pile_systeme_tampon;
struct_liste_pile_systeme *pile_systeme_tampon;	struct_liste_pile_systeme *pile_systeme_tampon;

unsigned long taille_pile_objets;	integer8 taille_pile_objets;
struct_objet *pile_objets;	struct_objet *pile_objets;

# define TAILLE_CACHE 1024	# define TAILLE_CACHE 1024
	# define CACHE(type, nom) \
unsigned long *objets_adr[TAILLE_CACHE];	type *objets_##nom[TAILLE_CACHE]; \
int pointeur_adr;	int pointeur_##nom;

logical8 *objets_bin[TAILLE_CACHE];	# define CACHE2(type, nom) \
int pointeur_bin;	type *nom[TAILLE_CACHE]; \
	int pointeur_##nom;
complex16 *objets_cpl[TAILLE_CACHE];
int pointeur_cpl;	CACHE(integer8, adr)
	CACHE(logical8, bin)
struct fonction *objets_fct[TAILLE_CACHE];	CACHE(complex16, cpl)
int pointeur_fct;	CACHE(struct_fonction, fct)
	CACHE(integer8, int)
integer8 *objets_int[TAILLE_CACHE];	CACHE(struct_matrice, mat)
int pointeur_int;	CACHE(struct_nom, nom)
	CACHE(real8, rel)
struct_matrice *objets_mat[TAILLE_CACHE];	CACHE(struct_tableau, tab)
int pointeur_mat;	CACHE(struct_vecteur, vec)

struct_nom *objets_nom[TAILLE_CACHE];	CACHE2(struct_liste_chainee, maillons)
int pointeur_nom;	CACHE2(struct_arbre_variables, variables_noeud)
	CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud)
real8 *objets_rel[TAILLE_CACHE];	CACHE2(struct_liste_variables, variables_feuille)
int pointeur_rel;	CACHE2(struct_variable, variables_variable)
	CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
struct_tableau *objets_tab[TAILLE_CACHE];	CACHE2(struct_arbre_variables_partagees *,variables_tableau_noeuds_partages)
int pointeur_tab;

struct_vecteur *objets_vec[TAILLE_CACHE];
int pointeur_vec;

struct_liste_chainee *maillons[TAILLE_CACHE];
int pointeur_maillons;
} struct_processus;	} struct_processus;
#endif	#endif

/*
--------------------------------------------------------------------------------
Structures instruction intrinseque
--------------------------------------------------------------------------------
*/

#ifndef RPLARGS
typedef struct instruction
{
struct instruction **noeud;
void (feuille)(struct_processus );
} struct_instruction;
#endif


/*
--------------------------------------------------------------------------------
Structure fonction
--------------------------------------------------------------------------------
*/

#ifndef RPLARGS
typedef struct fonction
{
unsigned char *nom_fonction;
unsigned long nombre_arguments;

void (fonction)(struct_processus );

volatile struct_liste_chainee *prediction_saut;
volatile logical1 prediction_execution;
} struct_fonction;
#endif


/*	/*
================================================================================	================================================================================
Line 1846 typedef struct fonction	Line 2421 typedef struct fonction

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Procédures d'exécution des mots-clef du langage RPL/2	ProcÃ©dures d'exÃ©cution des mots-clef du langage RPL/2
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

// BEGIN C PROTOTYPES	// BEGIN C PROTOTYPES
void instruction_sensible_e(struct_processus *s_etat_processus);	void instruction_sensible_e(struct_processus *s_etat_processus);
void instruction_sensible_i(struct_processus *s_etat_processus);	void instruction_sensible_i(struct_processus *s_etat_processus);
	void instruction_sensible_infinity(struct_processus *s_etat_processus);

void instruction_abort(struct_processus *s_etat_processus);	void instruction_abort(struct_processus *s_etat_processus);
void instruction_abs(struct_processus *s_etat_processus);	void instruction_abs(struct_processus *s_etat_processus);
Line 1870 void instruction_asl(struct_processus *s	Line 2446 void instruction_asl(struct_processus *s
void instruction_asr(struct_processus *s_etat_processus);	void instruction_asr(struct_processus *s_etat_processus);
void instruction_atan(struct_processus *s_etat_processus);	void instruction_atan(struct_processus *s_etat_processus);
void instruction_atanh(struct_processus *s_etat_processus);	void instruction_atanh(struct_processus *s_etat_processus);
	void instruction_atexit(struct_processus *s_etat_processus);
	void instruction_atpoke(struct_processus *s_etat_processus);
void instruction_autoscale(struct_processus *s_etat_processus);	void instruction_autoscale(struct_processus *s_etat_processus);
void instruction_axes(struct_processus *s_etat_processus);	void instruction_axes(struct_processus *s_etat_processus);

void instruction_b_vers_r(struct_processus *s_etat_processus);	void instruction_b_vers_r(struct_processus *s_etat_processus);
void instruction_backspace(struct_processus *s_etat_processus);	void instruction_backspace(struct_processus *s_etat_processus);
	void instruction_backtrace(struct_processus *s_etat_processus);
void instruction_beep(struct_processus *s_etat_processus);	void instruction_beep(struct_processus *s_etat_processus);
void instruction_bessel(struct_processus *s_etat_processus);	void instruction_bessel(struct_processus *s_etat_processus);
void instruction_bin(struct_processus *s_etat_processus);	void instruction_bin(struct_processus *s_etat_processus);
Line 1885 void instruction_ceil(struct_processus *	Line 2464 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);
void instruction_close(struct_processus *s_etat_processus);	void instruction_close(struct_processus *s_etat_processus);
	void instruction_clratexit(struct_processus *s_etat_processus);
	void instruction_clratpoke(struct_processus *s_etat_processus);
void instruction_clrcntxt(struct_processus *s_etat_processus);	void instruction_clrcntxt(struct_processus *s_etat_processus);
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);
Line 1903 void instruction_col_fleche(struct_proce	Line 2485 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 1917 void instruction_cosh(struct_processus *	Line 2500 void instruction_cosh(struct_processus *
void instruction_cov(struct_processus *s_etat_processus);	void instruction_cov(struct_processus *s_etat_processus);
void instruction_cr(struct_processus *s_etat_processus);	void instruction_cr(struct_processus *s_etat_processus);
void instruction_create(struct_processus *s_etat_processus);	void instruction_create(struct_processus *s_etat_processus);
	void instruction_critical(struct_processus *s_etat_processus);
void instruction_crmtx(struct_processus *s_etat_processus);	void instruction_crmtx(struct_processus *s_etat_processus);
void instruction_cross(struct_processus *s_etat_processus);	void instruction_cross(struct_processus *s_etat_processus);
void instruction_crsmphr(struct_processus *s_etat_processus);	void instruction_crsmphr(struct_processus *s_etat_processus);
Line 1942 void instruction_detach(struct_processus	Line 2526 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 1968 void instruction_elseif(struct_processus	Line 2553 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 2001 void instruction_fleche_str(struct_proce	Line 2587 void instruction_fleche_str(struct_proce
void instruction_fleche_table(struct_processus *s_etat_processus);	void instruction_fleche_table(struct_processus *s_etat_processus);
void instruction_floor(struct_processus *s_etat_processus);	void instruction_floor(struct_processus *s_etat_processus);
void instruction_for(struct_processus *s_etat_processus);	void instruction_for(struct_processus *s_etat_processus);
	void instruction_forall(struct_processus *s_etat_processus);
void instruction_format(struct_processus *s_etat_processus);	void instruction_format(struct_processus *s_etat_processus);
void instruction_fp(struct_processus *s_etat_processus);	void instruction_fp(struct_processus *s_etat_processus);
void instruction_fs_test(struct_processus *s_etat_processus);	void instruction_fs_test(struct_processus *s_etat_processus);
Line 2039 void instruction_ifft(struct_processus *	Line 2626 void instruction_ifft(struct_processus *
void instruction_ift(struct_processus *s_etat_processus);	void instruction_ift(struct_processus *s_etat_processus);
void instruction_ifte(struct_processus *s_etat_processus);	void instruction_ifte(struct_processus *s_etat_processus);
void instruction_im(struct_processus *s_etat_processus);	void instruction_im(struct_processus *s_etat_processus);
	void instruction_implicit(struct_processus *s_etat_processus);
void instruction_in(struct_processus *s_etat_processus);	void instruction_in(struct_processus *s_etat_processus);
void instruction_incr(struct_processus *s_etat_processus);	void instruction_incr(struct_processus *s_etat_processus);
void instruction_indep(struct_processus *s_etat_processus);	void instruction_indep(struct_processus *s_etat_processus);
void instruction_input(struct_processus *s_etat_processus);	void instruction_input(struct_processus *s_etat_processus);
	void instruction_infinity(struct_processus *s_etat_processus);
void instruction_inquire(struct_processus *s_etat_processus);	void instruction_inquire(struct_processus *s_etat_processus);
void instruction_int(struct_processus *s_etat_processus);	void instruction_int(struct_processus *s_etat_processus);
void instruction_interrupt(struct_processus *s_etat_processus);	void instruction_interrupt(struct_processus *s_etat_processus);
Line 2066 void instruction_lcd_fleche(struct_proce	Line 2655 void instruction_lcd_fleche(struct_proce
void instruction_lchol(struct_processus *s_etat_processus);	void instruction_lchol(struct_processus *s_etat_processus);
void instruction_le(struct_processus *s_etat_processus);	void instruction_le(struct_processus *s_etat_processus);
void instruction_legv(struct_processus *s_etat_processus);	void instruction_legv(struct_processus *s_etat_processus);
	void instruction_limit(struct_processus *s_etat_processus);
void instruction_line(struct_processus *s_etat_processus);	void instruction_line(struct_processus *s_etat_processus);
void instruction_list_fleche(struct_processus *s_etat_processus);	void instruction_list_fleche(struct_processus *s_etat_processus);
void instruction_ln(struct_processus *s_etat_processus);	void instruction_ln(struct_processus *s_etat_processus);
Line 2079 void instruction_lq(struct_processus *s_	Line 2669 void instruction_lq(struct_processus *s_
void instruction_lsq(struct_processus *s_etat_processus);	void instruction_lsq(struct_processus *s_etat_processus);
void instruction_lt(struct_processus *s_etat_processus);	void instruction_lt(struct_processus *s_etat_processus);
void instruction_lu(struct_processus *s_etat_processus);	void instruction_lu(struct_processus *s_etat_processus);
	void instruction_l_vers_t(struct_processus *s_etat_processus);

void instruction_mant(struct_processus *s_etat_processus);	void instruction_mant(struct_processus *s_etat_processus);
void instruction_mark(struct_processus *s_etat_processus);	void instruction_mark(struct_processus *s_etat_processus);
Line 2087 void instruction_maxs(struct_processus *	Line 2678 void instruction_maxs(struct_processus *
void instruction_mclrin(struct_processus *s_etat_processus);	void instruction_mclrin(struct_processus *s_etat_processus);
void instruction_mean(struct_processus *s_etat_processus);	void instruction_mean(struct_processus *s_etat_processus);
void instruction_mem(struct_processus *s_etat_processus);	void instruction_mem(struct_processus *s_etat_processus);
	void instruction_memlock(struct_processus *s_etat_processus);
	void instruction_memunlock(struct_processus *s_etat_processus);
void instruction_min(struct_processus *s_etat_processus);	void instruction_min(struct_processus *s_etat_processus);
void instruction_mins(struct_processus *s_etat_processus);	void instruction_mins(struct_processus *s_etat_processus);
void instruction_mod(struct_processus *s_etat_processus);	void instruction_mod(struct_processus *s_etat_processus);
Line 2131 void instruction_pmax(struct_processus *	Line 2724 void instruction_pmax(struct_processus *
void instruction_pmin(struct_processus *s_etat_processus);	void instruction_pmin(struct_processus *s_etat_processus);
void instruction_poke(struct_processus *s_etat_processus);	void instruction_poke(struct_processus *s_etat_processus);
void instruction_polar(struct_processus *s_etat_processus);	void instruction_polar(struct_processus *s_etat_processus);
	void instruction_poll(struct_processus *s_etat_processus);
void instruction_pos(struct_processus *s_etat_processus);	void instruction_pos(struct_processus *s_etat_processus);
void instruction_pourcent(struct_processus *s_etat_processus);	void instruction_pourcent(struct_processus *s_etat_processus);
void instruction_pourcent_ch(struct_processus *s_etat_processus);	void instruction_pourcent_ch(struct_processus *s_etat_processus);
Line 2141 void instruction_print(struct_processus	Line 2735 void instruction_print(struct_processus
void instruction_private(struct_processus *s_etat_processus);	void instruction_private(struct_processus *s_etat_processus);
void instruction_prlcd(struct_processus *s_etat_processus);	void instruction_prlcd(struct_processus *s_etat_processus);
void instruction_prmd(struct_processus *s_etat_processus);	void instruction_prmd(struct_processus *s_etat_processus);
	void instruction_procid(struct_processus *s_etat_processus);
void instruction_prompt(struct_processus *s_etat_processus);	void instruction_prompt(struct_processus *s_etat_processus);
void instruction_protect(struct_processus *s_etat_processus);	void instruction_protect(struct_processus *s_etat_processus);
void instruction_prst(struct_processus *s_etat_processus);	void instruction_prst(struct_processus *s_etat_processus);
Line 2186 void instruction_read(struct_processus *	Line 2781 void instruction_read(struct_processus *
void instruction_recode(struct_processus *s_etat_processus);	void instruction_recode(struct_processus *s_etat_processus);
void instruction_recv(struct_processus *s_etat_processus);	void instruction_recv(struct_processus *s_etat_processus);
void instruction_redraw(struct_processus *s_etat_processus);	void instruction_redraw(struct_processus *s_etat_processus);
	void instruction_regex(struct_processus *s_etat_processus);
void instruction_relax(struct_processus *s_etat_processus);	void instruction_relax(struct_processus *s_etat_processus);
void instruction_remove(struct_processus *s_etat_processus);	void instruction_remove(struct_processus *s_etat_processus);
void instruction_res(struct_processus *s_etat_processus);	void instruction_res(struct_processus *s_etat_processus);
	void instruction_restart(struct_processus *s_etat_processus);
void instruction_recall(struct_processus *s_etat_processus);	void instruction_recall(struct_processus *s_etat_processus);
void instruction_regv(struct_processus *s_etat_processus);	void instruction_regv(struct_processus *s_etat_processus);
void instruction_repeat(struct_processus *s_etat_processus);	void instruction_repeat(struct_processus *s_etat_processus);
Line 2197 void instruction_return(struct_processus	Line 2794 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 2254 void instruction_sqlquery(struct_process	Line 2853 void instruction_sqlquery(struct_process
void instruction_sqrt(struct_processus *s_etat_processus);	void instruction_sqrt(struct_processus *s_etat_processus);
void instruction_sr(struct_processus *s_etat_processus);	void instruction_sr(struct_processus *s_etat_processus);
void instruction_srb(struct_processus *s_etat_processus);	void instruction_srb(struct_processus *s_etat_processus);
	void instruction_srev(struct_processus *s_etat_processus);
void instruction_sst(struct_processus *s_etat_processus);	void instruction_sst(struct_processus *s_etat_processus);
void instruction_star_d(struct_processus *s_etat_processus);	void instruction_star_d(struct_processus *s_etat_processus);
void instruction_star_h(struct_processus *s_etat_processus);	void instruction_star_h(struct_processus *s_etat_processus);
Line 2311 void instruction_trn(struct_processus *s	Line 2911 void instruction_trn(struct_processus *s
void instruction_trnc(struct_processus *s_etat_processus);	void instruction_trnc(struct_processus *s_etat_processus);
void instruction_true(struct_processus *s_etat_processus);	void instruction_true(struct_processus *s_etat_processus);
void instruction_type(struct_processus *s_etat_processus);	void instruction_type(struct_processus *s_etat_processus);
	void instruction_t_vers_l(struct_processus *s_etat_processus);

void instruction_ucase(struct_processus *s_etat_processus);	void instruction_ucase(struct_processus *s_etat_processus);
void instruction_uchol(struct_processus *s_etat_processus);	void instruction_uchol(struct_processus *s_etat_processus);
void instruction_undo(struct_processus *s_etat_processus);	void instruction_uncompress(struct_processus *s_etat_processus);
void instruction_unlock(struct_processus *s_etat_processus);	void instruction_unlock(struct_processus *s_etat_processus);
void instruction_unprotect(struct_processus *s_etat_processus);	void instruction_unprotect(struct_processus *s_etat_processus);
void instruction_until(struct_processus *s_etat_processus);	void instruction_until(struct_processus *s_etat_processus);
Line 2358 void instruction_yield(struct_processus	Line 2959 void instruction_yield(struct_processus

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Procédures	ProcÃ©dures
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
void affectation_interruptions_logicielles(struct_processus *s_etat_processus);	void affectation_interruptions_logicielles(struct_processus *s_etat_processus);
void affichage_pile(struct_processus *s_etat_processus,	void affichage_pile(struct_processus *s_etat_processus,
struct_liste_chainee *l_element_courant, unsigned long	struct_liste_chainee *l_element_courant, integer8 niveau_courant);
niveau_courant);
#endif	#endif

void allocation(struct_processus s_etat_processus, enum t_type type);
void allocation_maillon(struct_processus s_etat_processus);	void allocation_maillon(struct_processus s_etat_processus);

#ifndef RPLARGS	#ifndef RPLARGS
void analyse(struct_processus s_etat_processus, void (fonction)());	void analyse(struct_processus s_etat_processus, void (fonction)());
inline void analyse_instruction(struct_processus s_etat_processus,	void analyse_instruction(struct_processus s_etat_processus,
unsigned char *candidat);	unsigned char *candidat);
void appel_gnuplot(struct_processus *s_etat_processus,	void appel_gnuplot(struct_processus *s_etat_processus,
unsigned char persistance);	unsigned char persistance);
void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);	void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
void cond(struct_processus *s_etat_processus,	void cond(struct_processus *s_etat_processus,
struct_matrice s_matrice, real8 condition);	struct_matrice s_matrice, real8 condition);
	void conversion_chaine(struct_processus *s_etat_processus,
	unsigned char *chaine, unsigned char type);
void conversion_decimal_vers_hms(real8 *angle);	void conversion_decimal_vers_hms(real8 *angle);
void conversion_degres_vers_radians(real8 *angle);	void conversion_degres_vers_radians(real8 *angle);
void conversion_element_tex(unsigned char *element, unsigned char fonction);	void conversion_element_tex(unsigned char *element, unsigned char fonction);
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,
	unsigned char *chaine_sortie, integer8 longueur);
void conversion_radians_vers_degres(real8 *angle);	void conversion_radians_vers_degres(real8 *angle);
	void copie_arbre_variables(struct_processus *s_etat_processus,
	struct_processus *s_nouvel_etat_processus);
void correction_formateur_tex(struct_processus *s_etat_processus,	void correction_formateur_tex(struct_processus *s_etat_processus,
unsigned char **ligne);	unsigned char **ligne);
void debug_memoire_verification(struct_processus *s_etat_processus);
void depilement_pile_systeme(struct_processus *s_etat_processus);	void depilement_pile_systeme(struct_processus *s_etat_processus);
void derivation(struct_processus *s_etat_processus,	void derivation(struct_processus *s_etat_processus,
struct_objet **s_expression);	struct_objet **s_expression);
Line 2398 void determinant(struct_processus *s_eta	Line 3002 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 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 2422 void formateur_elementaire_tex(struct_pr	Line 3027 void formateur_elementaire_tex(struct_pr
file fichier, struct_objet s_objet, unsigned char environnement);	file fichier, struct_objet s_objet, unsigned char environnement);
void impression_pile(struct_processus *s_etat_processus,	void impression_pile(struct_processus *s_etat_processus,
struct_liste_chainee *l_element_courant,	struct_liste_chainee *l_element_courant,
unsigned char methode, unsigned long niveau_courant);	unsigned char methode, integer8 niveau_courant);
void impression_tex(struct_processus *s_etat_processus);	void impression_tex(struct_processus *s_etat_processus);
void informations(struct_processus *s_etat_processus);	void informations(struct_processus *s_etat_processus);
void initialisation_allocateur(struct_processus *s_etat_processus);	void initialisation_allocateur(struct_processus *s_etat_processus);
void initialisation_completion(void);	void initialisation_completion(void);
	void initialisation_contexte_cas(struct_processus *s_etat_processus);
void initialisation_drapeaux(struct_processus *s_etat_processus);	void initialisation_drapeaux(struct_processus *s_etat_processus);
void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,	void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,
logical1 initialisation_automatique, unsigned long int racine);	logical1 initialisation_automatique, integer8 racine);
void initialisation_instructions(struct_processus *s_etat_processus);	void initialisation_instructions(struct_processus *s_etat_processus);
	void initialisation_variables(struct_processus *s_etat_processus);
#endif	#endif

void initialisation_objet(struct_objet *s_objet);	void initialisation_objet(struct_objet *s_objet);
Line 2443 void insertion_thread_surveillance(struc	Line 3050 void insertion_thread_surveillance(struc
void integrale_romberg(struct_processus *s_etat_processus,	void integrale_romberg(struct_processus *s_etat_processus,
struct_objet s_expression, unsigned char variable,	struct_objet s_expression, unsigned char variable,
real8 a, real8 b, real8 precision);	real8 a, real8 b, real8 precision);
void interruption1(int signal, siginfo_t siginfo, void context);	void interface_cas(struct_processus *s_etat_processus,
void interruption2(int signal, siginfo_t siginfo, void context);	enum t_rplcas_commandes commande);
void interruption3(int signal, siginfo_t siginfo, void context);	void interruption1(int signal);
void interruption4(int signal, siginfo_t siginfo, void context);	void interruption2(int signal);
void interruption5(int signal, siginfo_t siginfo, void context);	void interruption3(int signal);
void interruption6(int signal, siginfo_t siginfo, void context);	void interruption4(int signal);
void interruption7(int signal, siginfo_t siginfo, void context);	void interruption5(int signal);
void interruption8(int signal, siginfo_t siginfo, void context);	void interruption6(int signal);
void interruption9(int signal, siginfo_t siginfo, void context);	void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);
void interruption10(int signal, siginfo_t siginfo, void context);
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 2467 void liberation_maillon(struct_processus	Line 3073 void liberation_maillon(struct_processus
void liberation_allocateur(struct_processus *s_etat_processus);	void liberation_allocateur(struct_processus *s_etat_processus);
void liberation_arbre_instructions(struct_processus *s_etat_processus,	void liberation_arbre_instructions(struct_processus *s_etat_processus,
struct_instruction *arbre);	struct_instruction *arbre);
	void liberation_arbre_variables(struct_processus *s_etat_processus,
	struct_arbre_variables *arbre, logical1 definitions);
	void liberation_arbre_variables_partagees(struct_processus *s_etat_processus,
	struct_arbre_variables_partagees *arbre);
	void liberation_contexte_cas(struct_processus *s_etat_processus);
void liberation_generateur_aleatoire(struct_processus *s_etat_processus);	void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
	void liberation_mutexes_arbre_variables_partagees(struct_processus
	s_etat_processus, struct_arbre_variables_partagees l_element_courant);
void liberation_threads(struct_processus *s_etat_processus);	void liberation_threads(struct_processus *s_etat_processus);
void liberation_profil(struct_processus *s_etat_processus);	void liberation_profil(struct_processus *s_etat_processus);
void localisation_courante(struct_processus *s_etat_processus);	void localisation_courante(struct_processus *s_etat_processus);
Line 2483 void retrait_thread(struct_processus *s_	Line 3096 void retrait_thread(struct_processus *s_
void retrait_thread_surveillance(struct_processus *s_etat_processus,	void retrait_thread_surveillance(struct_processus *s_etat_processus,
struct_descripteur_thread *s_argument_thread);	struct_descripteur_thread *s_argument_thread);
void rplcore(struct_processus *s_etat_processus);	void rplcore(struct_processus *s_etat_processus);
inline void scrutation_injection(struct_processus *s_etat_processus);	#endif

	void scrutation_injection(struct_processus *s_etat_processus);

	#ifndef RPLARGS
	void scrutation_interruptions(struct_processus *s_etat_processus);
void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);	void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
void surveillance_processus(void argument);	void surveillance_processus(void argument);
void swap(void variable_1, void variable_2, unsigned long taille_octets);	void swap(void variable_1, void variable_2, integer8 taille_octets);
	void thread_signaux(void argument);
	void trace(struct_processus s_etat_processus, FILE flux);
void 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 2512 void verrouillage_threads_concurrents(st	Line 3132 void verrouillage_threads_concurrents(st

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions de sommation de vecteur dans perte de précision	Fonctions de gestion des signaux
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

real8 sommation_vecteur_reel(real8 vecteur, unsigned long taille,	#ifndef RPLARGS
	void creation_queue_signaux(struct_processus *s_etat_processus);
	void liberation_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,
	enum signaux_rpl signal);
	int envoi_signal_processus(pid_t pid, enum signaux_rpl signal);
	int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);
	#endif

	/*
	--------------------------------------------------------------------------------
	Fonctions de sommation de vecteur dans perte de prÃ©cision
	--------------------------------------------------------------------------------
	*/

	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 2528 complex16 sommation_vecteur_complexe(com	Line 3164 complex16 sommation_vecteur_complexe(com
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
int rplinit(int argc, char argv[], unsigned char *resultats, char rpl_home);	int rplinit(int argc, char argv[], char envp[],
	unsigned char **resultats, char rpl_home);
#endif	#endif

/*	/*
Line 2539 int rplinit(int argc, char *argv[], unsi	Line 3176 int rplinit(int argc, char *argv[], unsi

#ifndef RPLARGS	#ifndef RPLARGS
real8 correlation_statistique(struct_matrice *s_matrice,	real8 correlation_statistique(struct_matrice *s_matrice,
unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur);	integer8 colonne_1, integer8 colonne_2, logical1 *erreur);
real8 covariance_statistique(struct_matrice *s_matrice,	real8 covariance_statistique(struct_matrice *s_matrice,
unsigned long colonne_1, unsigned long colonne_2,	integer8 colonne_1, integer8 colonne_2,
unsigned char type, logical1 *erreur);	unsigned char type, logical1 *erreur);
struct_vecteur ecart_type_statistique(struct_matrice s_matrice,	struct_vecteur ecart_type_statistique(struct_matrice s_matrice,
unsigned char type);	unsigned char type);
struct_vecteur moyenne_statistique(struct_matrice s_matrice);	struct_vecteur moyenne_statistique(struct_matrice s_matrice);
struct_vecteur sommation_colonne_statistique(struct_matrice s_matrice,	struct_vecteur sommation_colonne_statistique(struct_matrice s_matrice,
unsigned long colonne);	integer8 colonne);
struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice	struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice
*s_matrice, unsigned long colonne_1, unsigned long colonne_2);	*s_matrice, integer8 colonne_1, integer8 colonne_2);
struct_vecteur sommation_statistique(struct_matrice s_matrice);	struct_vecteur sommation_statistique(struct_matrice s_matrice);
struct_vecteur variance_statistique(struct_matrice s_matrice,	struct_vecteur variance_statistique(struct_matrice s_matrice,
unsigned char type);	unsigned char type);
Line 2557 struct_vecteur *variance_statistique(str	Line 3194 struct_vecteur *variance_statistique(str

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Gestion des bibliothèques	Gestion des bibliothÃ¨ques
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2575 struct_liste_chainee *depilement_pile_op	Line 3212 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 2586 struct_liste_chainee *sauvegarde_argumen	Line 3223 struct_liste_chainee *sauvegarde_argumen
#ifndef RPLARGS	#ifndef RPLARGS
unsigned char analyse_algebrique(struct_processus s_etat_processus,	unsigned char analyse_algebrique(struct_processus s_etat_processus,
unsigned char chaine_algebrique, struct_liste_chainee *l_base_liste);	unsigned char chaine_algebrique, struct_liste_chainee *l_base_liste);
unsigned char *recherche_chemin_fichiers_temporaires(struct_processus	unsigned char analyse_flux(struct_processus s_etat_processus,
*s_etat_processus);	unsigned char *flux, integer8 longueur);
	unsigned char chiffrement(const EVP_CIPHER type_chiffrement,
	logical1 encodage, unsigned char *message, integer8 longueur_message,
	unsigned char *clef, integer8 longueur_clef,
	unsigned char *vecteur_initialisation,
	integer8 *longueur_message_chiffre);
unsigned char compactage(unsigned char chaine);	unsigned char compactage(unsigned char chaine);
unsigned char conversion_majuscule(unsigned char chaine);	unsigned char conversion_majuscule(unsigned char chaine);
unsigned char creation_nom_fichier(struct_processus s_etat_processus,	unsigned char creation_nom_fichier(struct_processus s_etat_processus,
unsigned char *chemin);	unsigned char *chemin);
unsigned char extraction_chaine(unsigned char chaine, unsigned long i,	unsigned char *date_compilation();
unsigned long j);	unsigned char extraction_chaine(unsigned char chaine, integer8 i, integer8 j);
unsigned char formateur(struct_processus s_etat_processus, long offset,	unsigned char formateur(struct_processus s_etat_processus, long offset,
struct_objet *s_objet);	struct_objet *s_objet);
unsigned char formateur_fichier(struct_processus s_etat_processus,	unsigned char formateur_fichier(struct_processus s_etat_processus,
struct_objet s_objet, struct_objet s_format,	struct_objet s_objet, struct_objet s_format,
long longueur, long longueur_champ, unsigned char format,	integer8 longueur, integer8 longueur_champ, unsigned char format,
unsigned char type, long longueur_effective, long recursivite);	unsigned char type, integer8 longueur_effective, integer8 recursivite,
	logical1 export_fichier);
	unsigned char formateur_flux(struct_processus s_etat_processus,
	unsigned char donnees, integer8 longueur);
unsigned char formateur_fichier_nombre(struct_processus s_etat_processus,	unsigned char formateur_fichier_nombre(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ, unsigned char format);	integer8 longueur, integer8 longueur_champ, unsigned char format);
	unsigned char *formateur_fichier_binaire_nombre(struct_processus
	s_etat_processus, void valeur_numerique, unsigned char type_entree,
	unsigned char type, integer8 longueur, integer8 *longueur_conversion);
unsigned char formateur_fichier_reel(struct_processus s_etat_processus,	unsigned char formateur_fichier_reel(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ, unsigned char format);	integer8 longueur, integer8 longueur_champ, unsigned char format);
unsigned char formateur_nombre(struct_processus s_etat_processus,	unsigned char formateur_nombre(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type);	void *valeur_numerique, unsigned char type);
unsigned char formateur_reel(struct_processus s_etat_processus,	unsigned char formateur_reel(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type);	void *valeur_numerique, unsigned char type);
unsigned char messages(struct_processus s_etat_processus);	unsigned char messages(struct_processus s_etat_processus);
	unsigned char pointeur_ieme_caractere(struct_processus s_etat_processus,
	unsigned char *chaine, integer8 position);
unsigned char purification_chaine(unsigned char chaine);	unsigned char purification_chaine(unsigned char chaine);
	unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
	*s_etat_processus);
unsigned char reencodage(struct_processus s_etat_processus,	unsigned char reencodage(struct_processus s_etat_processus,
unsigned char chaine_entree, unsigned char codage_entree,	unsigned char chaine_entree, unsigned char codage_entree,
unsigned char *codage_sortie);	unsigned char *codage_sortie);
Line 2628 unsigned char *transliteration(struct_pr	Line 3280 unsigned char *transliteration(struct_pr

#ifndef RPLARGS	#ifndef RPLARGS
logical1 analyse_syntaxique(struct_processus *s_etat_processus);	logical1 analyse_syntaxique(struct_processus *s_etat_processus);
	logical1 arret_thread_signaux(struct_processus *s_etat_processus);
logical1 caracteristiques_fichier(struct_processus *s_etat_processus,	logical1 caracteristiques_fichier(struct_processus *s_etat_processus,
unsigned char nom, logical1 existence, logical1 *ouverture,	unsigned char nom, logical1 existence, logical1 *ouverture,
unsigned long *unite);	unsigned long *unite);
logical1 controle(struct_processus s_etat_processus, unsigned char fichier,	logical1 controle(struct_processus s_etat_processus, unsigned char fichier,
unsigned char type, unsigned char somme_candidate);	unsigned char type, unsigned char somme_candidate);
	logical1 controle_integrite(struct_processus *s_etat_processus,
	unsigned char executable_candidat, unsigned char executable);
logical1 creation_variable(struct_processus *s_etat_processus,	logical1 creation_variable(struct_processus *s_etat_processus,
struct_variable *s_variable,	struct_variable *s_variable,
unsigned char autorisation_creation_variable_statique,	unsigned char autorisation_creation_variable_statique,
Line 2649 logical1 destruction_fichier(unsigned ch	Line 3304 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,
	sqlite3 *sqlite, logical1 binaire);
	logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
	sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
	logical1 lancement_thread_signaux(struct_processus *s_etat_processus);
logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);	logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);
	logical1 recherche_instruction_suivante_recursive(
	struct_processus *s_etat_processus, integer8 recursivite);
logical1 retrait_variable(struct_processus *s_etat_processus,	logical1 retrait_variable(struct_processus *s_etat_processus,
unsigned char *nom_variable, unsigned char type);	unsigned char *nom_variable, unsigned char type);
logical1 retrait_variable_par_niveau(struct_processus *s_etat_processus);	logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus);
logical1 retrait_variable_partagee(struct_processus *s_etat_processus,	logical1 retrait_variable_partagee(struct_processus *s_etat_processus,
unsigned char *nom_variable, union_position_variable position);	unsigned char *nom_variable, union_position_variable position);
	logical1 retrait_variables_partagees_locales(
	struct_processus *s_etat_processus);
logical1 retrait_variable_statique(struct_processus *s_etat_processus,	logical1 retrait_variable_statique(struct_processus *s_etat_processus,
unsigned char *nom_variable, union_position_variable position);	unsigned char *nom_variable, union_position_variable position);
	logical1 retrait_variables_statiques_locales(
	struct_processus *s_etat_processus);
logical1 sequenceur(struct_processus *s_etat_processus);	logical1 sequenceur(struct_processus *s_etat_processus);
logical1 sequenceur_optimise(struct_processus *s_etat_processus);	logical1 sequenceur_optimise(struct_processus *s_etat_processus);
#endif	#endif
Line 2673 logical1 sequenceur_optimise(struct_proc	Line 3339 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 2680 logical1 ecriture_pipe(struct_processus	Line 3347 logical1 ecriture_pipe(struct_processus
struct_objet *s_objet);	struct_objet *s_objet);
logical1 recherche_variable(struct_processus *s_etat_processus,	logical1 recherche_variable(struct_processus *s_etat_processus,
unsigned char *nom_variable);	unsigned char *nom_variable);
logical1 recherche_variable_partagee(struct_processus *s_etat_processus,	logical1 recherche_variable_globale(struct_processus *s_etat_processus,
unsigned char *nom_variable, union_position_variable position,	unsigned char *nom_variable);
unsigned char origine);
logical1 recherche_variable_statique(struct_processus *s_etat_processus,
unsigned char *nom_variable, union_position_variable position,
unsigned char origine);
logical1 test_cfsf(struct_processus *s_etat_processus,	logical1 test_cfsf(struct_processus *s_etat_processus,
unsigned char indice_drapeau);	unsigned char indice_drapeau);
logical1 test_expression_rpn(unsigned char *chaine);	logical1 test_expression_rpn(unsigned char *chaine);
logical1 test_fonction(unsigned char *chaine);	logical1 test_fonction(unsigned char *chaine);
	logical1 validation_chaine(unsigned char *chaine);
#endif	#endif

/*	/*
Line 2699 logical1 test_fonction(unsigned char *ch	Line 3363 logical1 test_fonction(unsigned char *ch
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
inline 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);
inline 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 2712 inline ssize_t write_atomic(struct_proce	Line 3376 inline ssize_t write_atomic(struct_proce
*/	*/

int alsprintf(unsigned char *strp, const char fmt, ...);	int alsprintf(unsigned char *strp, const char fmt, ...);
	int interruption_violation_access(void *adresse_fautive, int gravite);
	#ifndef RPLARGS
	integer8 liste_variables(struct_processus *s_etat_processus,
	struct_tableau_variables *tableau);
	integer8 nombre_variables(struct_processus *s_etat_processus);
	int readline_analyse_syntaxique(int count, int key);
	int readline_effacement(int count, int key);
	#endif
int tex_fprintf(struct_processus *s_etat_processus,	int tex_fprintf(struct_processus *s_etat_processus,
file flux, const char format, ...);	file flux, const char format, ...);
int transliterated_fprintf(struct_processus s_etat_processus, file flux,	int transliterated_fprintf(struct_processus s_etat_processus, file flux,
Line 2728 int wrapper_instruction_intrinseque(void	Line 3400 int wrapper_instruction_intrinseque(void

#ifndef RPLARGS	#ifndef RPLARGS
unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);	unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);
unsigned char recherche_longueur_optimale(integer8 parametre);
#endif	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions retournant un INTEGER*8 (valeur binaire non signée)	Fonctions retournant un INTEGER*8 (valeur binaire non signÃ©e)
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2749 logical8 masque_entiers_binaires(struct_	Line 3420 logical8 masque_entiers_binaires(struct_

#ifndef RPLARGS	#ifndef RPLARGS
integer8 occupation_memoire(struct_objet *s_objet);	integer8 occupation_memoire(struct_objet *s_objet);
	integer8 longueur_chaine(struct_processus *s_etat_processus,
	unsigned char *chaine);
	integer8 position_caractere_de_chaine(struct_processus *s_etat_processus,
	unsigned char chaine, unsigned char position);
#endif	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)	Fonctions renvoyant une liste chaÃ®nÃ©e (pointeur sur *struct_liste_chainee)
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2774 struct_processus *copie_etat_processus(s	Line 3449 struct_processus *copie_etat_processus(s

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions renvoyant un pointeur sur un fichier (file *)	Fonctions renvoyant un pointeur sur un fichier (file *) ou un descripteur
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
file creation_fichier_tex(struct_processus s_etat_processus);	file creation_fichier_tex(struct_processus s_etat_processus);
file descripteur_fichier(struct_processus s_etat_processus,	struct_descripteur_fichier *descripteur_fichier(struct_processus
struct_fichier *s_fichier);	s_etat_processus, struct_fichier s_fichier);
#endif	#endif

/*	/*
Line 2793 file *descripteur_fichier(struct_process	Line 3468 file *descripteur_fichier(struct_process
struct_objet copie_objet(struct_processus s_etat_processus,	struct_objet copie_objet(struct_processus s_etat_processus,
struct_objet *s_objet, unsigned char type);	struct_objet *s_objet, unsigned char type);

	struct_objet allocation(struct_processus s_etat_processus, enum t_type type);
#ifndef RPLARGS	#ifndef RPLARGS
struct_objet formateur_date(struct_processus s_etat_processus,	struct_objet formateur_date(struct_processus s_etat_processus,
struct timeval *temps);	struct timeval *temps);
	struct_objet lecture_fichier_non_formate(struct_processus s_etat_processus,
	void *argument, integer8 longueur_buffer, logical1 recursivite);
struct_objet lecture_pipe(struct_processus s_etat_processus, int pipe);	struct_objet lecture_pipe(struct_processus s_etat_processus, int pipe);
struct_objet parametres_sql(struct_processus s_etat_processus,	struct_objet parametres_sql(struct_processus s_etat_processus,
struct_objet *s_parametres);	struct_objet *s_parametres);
struct_objet simplification(struct_processus s_etat_processus,	struct_objet simplification(struct_processus s_etat_processus,
struct_objet *s_objet);	struct_objet *s_objet);
#endif
	struct_arbre_variables allocation_noeud(struct_processus s_etat_processus);
	struct_arbre_variables **allocation_tableau_noeuds(
	struct_processus *s_etat_processus);

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions gérant les arbres de simplification	Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques
	ou *struct_liste_variables_partagees
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#ifndef RPLARGS	struct_liste_variables_statiques *recherche_variable_statique(struct_processus
struct_arbre creation_arbre(struct_processus s_etat_processus,	s_etat_processus, unsigned char nom_variable,
struct_objet **t_objets, unsigned long indice,	union_position_variable position, unsigned char origine);
unsigned long indice_maximal);	struct_liste_variables_partagees *recherche_variable_partagee(struct_processus
void liberation_arbre(struct_processus *s_etat_processus,	s_etat_processus, unsigned char nom_variable,
struct_arbre *s_noeud);	union_position_variable position, unsigned char origine);
void parcours_arbre(struct_processus s_etat_processus, struct_arbre s_noeud);
void simplification_arbre(struct_processus *s_etat_processus,
struct_arbre *s_noeud);
#endif	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions gérant la complétion automatique	Fonctions gÃ©rant la complÃ©tion automatique
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2834 char **completion_matches();	Line 3513 char **completion_matches();

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Arithmétique	ArithmÃ©tique
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2855 void f77multiplicationci_(complex16 *ca,	Line 3534 void f77multiplicationci_(complex16 *ca,
void f77multiplicationcr_(complex16 ca, real8 rb, complex16 *resultat);	void f77multiplicationcr_(complex16 ca, real8 rb, complex16 *resultat);

void f77puissancecc_(complex16 ca, complex16 cb, complex16 *resultat);	void f77puissancecc_(complex16 ca, complex16 cb, complex16 *resultat);
void f77puissanceci_(complex16 ca, integer8 ib, complex16 *resultat,	void f77puissanceci_(complex16 ca, integer8 ib, complex16 *resultat);
integer4 *troncature);
void f77puissancecr_(complex16 ca, real8 rb, complex16 *resultat);	void f77puissancecr_(complex16 ca, real8 rb, complex16 *resultat);
void f77puissanceic_(integer8 ia, complex16 cb, complex16 *resultat);	void f77puissanceic_(integer8 ia, complex16 cb, complex16 *resultat);
void f77puissanceii_(integer8 ia, integer8 ib, integer8 *resultat);	void f77puissanceii_(integer8 ia, integer8 ib, integer8 *resultat);
void f77puissanceir_(integer8 ia, real8 rb, real8 *resultat);	void f77puissanceir_(integer8 ia, real8 rb, real8 *resultat);
void f77puissancerc_(real8 ra, complex16 cb, complex16 *resultat);	void f77puissancerc_(real8 ra, complex16 cb, complex16 *resultat);
void f77puissanceri_(real8 ra, integer8 ib, real8 *resultat,	void f77puissanceri_(real8 ra, integer8 ib, real8 *resultat);
integer4 *troncature);
void f77puissancerr_(real8 ra, real8 rb, real8 *resultat);	void f77puissancerr_(real8 ra, real8 rb, real8 *resultat);

void f77racinecarreec_(complex16 ca, complex16 resultat);	void f77racinecarreec_(complex16 ca, complex16 resultat);
Line 2880 void f77soustractionrc_(real8 *ra, compl	Line 3557 void f77soustractionrc_(real8 *ra, compl

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Trigonométrie complexe	TrigonomÃ©trie complexe
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

Line 2977 void zgeev_(unsigned char *calcul_vp_gau	Line 3654 void zgeev_(unsigned char *calcul_vp_gau
integer4 *erreur, integer4 longueur_1, integer4 longueur_2);	integer4 *erreur, integer4 longueur_1, integer4 longueur_2);

/*	/*
* Valeurs propres généralisées	* Valeurs propres gÃ©nÃ©ralisÃ©es
*/	*/

void zggev_(unsigned char calcul_vp_gauches, unsigned char calcul_vp_droits,	void zggev_(unsigned char calcul_vp_gauches, unsigned char calcul_vp_droits,
Line 2990 void zggev_(unsigned char *calcul_vp_gau	Line 3667 void zggev_(unsigned char *calcul_vp_gau
integer4 *erreur, integer4 longueur_1, integer4 longueur_2);	integer4 *erreur, integer4 longueur_1, integer4 longueur_2);

/*	/*
* Moindres carrés	* Moindres carrÃ©s
*/	*/

void dgelsd_(integer4 nombre_lignes_a, integer4 nombre_colonnes_a,	void dgelsd_(integer4 nombre_lignes_a, integer4 nombre_colonnes_a,
Line 3005 void zgelsd_(integer4 *nombre_lignes_a,	Line 3682 void zgelsd_(integer4 *nombre_lignes_a,
real8 rwork, integer4 iwork, integer4 *info);	real8 rwork, integer4 iwork, integer4 *info);

/*	/*
* Moindres carrés généralisé	* Moindres carrÃ©s gÃ©nÃ©ralisÃ©
*/	*/

/*	/*
* Décomposition en valeurs singulières	* DÃ©composition en valeurs singuliÃ¨res
*/	*/

void dgesvd_(unsigned char jobu, unsigned char jobvh,	void dgesvd_(unsigned char jobu, unsigned char jobvh,
Line 3066 void zgees_(unsigned char *calcul_vecteu	Line 3743 void zgees_(unsigned char *calcul_vecteu
real8 rwork, logical4 bwork, integer4 *info,	real8 rwork, logical4 bwork, integer4 *info,
integer4 l1, integer4 l2);	integer4 l1, integer4 l2);

/* Déterminant et rang */	/* DÃ©terminant et rang */
void dgecon_(unsigned char norm, integer4 n, real8 a, integer4 lda,	void dgecon_(unsigned char norm, integer4 n, real8 a, integer4 lda,
real8 anorm, real8 rcond, real8 work, integer4 iwork,	real8 anorm, real8 rcond, real8 work, integer4 iwork,
integer4 *info, integer4 l1);	integer4 *info, integer4 l1);
Line 3087 void zgelsy_(integer4 m, integer4 n, i	Line 3764 void zgelsy_(integer4 m, integer4 n, i
#endif	#endif

/*	/*
* Fonction testant la requête d'arrêt (nécessaire pour tester le	* Fonction testant la requÃªte d'arrÃªt (nÃ©cessaire pour tester le
* drapeau depuis une bibliothèque).	* drapeau depuis une bibliothÃ¨que).
*/	*/

inline int test_arret(struct_processus *s_etat_processus);	int test_arret(struct_processus *s_etat_processus);

#endif	#endif

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.14
changed lines
	Added in v.1.256