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.76 and 1.202

version 1.76, 2011/03/06 16:44:15	version 1.202, 2013/03/05 16:20:47
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.21	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

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

Line 19	Line 19
================================================================================	================================================================================
*/	*/

	#define DEBUG_ERREURS
#ifndef INCLUSION_RPL	#ifndef INCLUSION_RPL
#define INCLUSION_RPL	#define INCLUSION_RPL

#define _GNU_SOURCE	#ifndef __RPLCAS
#define _POSIX_C_SOURCE 200112L	# define _GNU_SOURCE
	# define _XOPEN_SOURCE 700
	#endif

#define _REENTRANT	#define _REENTRANT

#ifdef Darwin	#ifndef __RPLCAS
# define _DARWIN_C_SOURCE	# ifdef Darwin
#endif	# define _DARWIN_C_SOURCE
	# endif

#ifdef OpenBSD	# ifdef OpenBSD
# define _BSD_SOURCE	# define _BSD_SOURCE
	# endif
#endif	#endif

#ifdef OS2	#ifdef OS2
# define _BSD_SOURCE	# ifndef __RPLCAS
# define _XOPEN_SOURCE 600	# define _BSD_SOURCE
	# endif

# include <types.h>	# include <types.h>
enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };	enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
Line 65	Line 71
#include <syslog.h>	#include <syslog.h>
#include <errno.h>	#include <errno.h>
#include <stdarg.h>	#include <stdarg.h>
	#include <poll.h>

#ifndef RPLARGS	#ifndef RPLARGS
# include <sys/mman.h>	# include <sys/mman.h>
Line 85	Line 92
# include <dlfcn.h>	# include <dlfcn.h>
# include <fcntl.h>	# include <fcntl.h>
# include <pthread.h>	# include <pthread.h>
	# include <regex.h>

# ifdef OS2	# ifdef OS2
# undef pthread_mutexattr_settype	# undef pthread_mutexattr_settype
Line 92	Line 100
# endif	# endif

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

Line 119	Line 125
ULONG *nopened;	ULONG *nopened;
ULONG allocated;	ULONG allocated;
} sem_t;	} sem_t;
# else	# else // IPCS_SYSV
typedef struct	typedef struct
{	{
int sem;	int sem;
	int alloue;
unsigned char *path;	unsigned char *path;
pid_t pid;	pid_t pid;
	pthread_t tid;
} sem_t;	} sem_t;
# endif	# endif

# define SEM_FAILED NULL	# ifndef SEM_FAILED
	# define SEM_FAILED NULL
	# endif

sem_t sem_open_SysV(const char nom, int oflag, ...);	sem_t sem_open_SysV(const char nom, int oflag, ...);
int sem_init_SysV(sem_t *sem, int shared, unsigned int value);	int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
int sem_close_SysV(sem_t *sem);	int sem_close_SysV(sem_t *sem);
int sem_wait_SysV(sem_t *sem);	int sem_wait_SysV(sem_t *sem);
int sem_trywait_SysV(sem_t *sem);	int sem_trywait_SysV(sem_t *sem);
	int sem_timedwait_SysV(sem_t sem, struct timespec ts);
int sem_post_SysV(sem_t *sem);	int sem_post_SysV(sem_t *sem);
int sem_getvalue_SysV(sem_t sem, int value);	int sem_getvalue_SysV(sem_t sem, int value);
int sem_unlink_SysV(const char *nom);	int sem_unlink_SysV(char *nom);
int sem_destroy_SysV(sem_t *sem);	int sem_destroy_SysV(sem_t *sem);
# endif	# endif

Line 154	Line 165
# include "iconv.h"	# include "iconv.h"

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

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

# define HAVE_INLINE	# define HAVE_INLINE
# define GSL_RANGE_CHECK_OFF	# define GSL_RANGE_CHECK_OFF
Line 200	Line 250
# endif	# endif
#endif	#endif

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

/*	/*
================================================================================	================================================================================
Bugs spécifiques	Bugs spécifiques
================================================================================	================================================================================
*/	*/

#ifdef _BROKEN_SIGINFO	// Néant
# define SIGHANDLER_ARGS int signal
# ifdef SA_SIGINFO
# undef SA_SIGINFO
# endif
# define SA_SIGINFO 0

# ifndef __BROKEN_SIGINFO_ROUTINES__

// pthread_kill() est une macro sous OS/2.
# ifdef pthread_kill
# undef pthread_kill
# endif

# define kill(a, b) kill_broken_siginfo(a, b)	/*
# define pthread_kill(a, b) pthread_kill_broken_siginfo(a, b)	================================================================================
# endif	TYPES
	================================================================================
	*/

int kill_broken_siginfo(pid_t pid, int signal);	typedef FILE file;
int pthread_kill_broken_siginfo(pthread_t tid, int signal);	typedef unsigned char t_8_bits;
pid_t origine_signal(int signal);
int queue_in(pid_t pid, int signal);	#ifndef RPLARGS
	# include "rpltypes-conv.h"
#else	#else
# define SIGHANDLER_ARGS int signal, siginfo_t siginfo, void context	# include "rpltypes.h"
#endif	#endif

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

	#define LONGUEUR_QUEUE_SIGNAUX 1024

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

	#ifndef RPLARGS
	typedef struct queue_signaux
	{
	# ifndef IPCS_SYSV
	# ifndef SEMAPHORES_NOMMES
	sem_t semaphore;
	sem_t signalisation;
	# endif
	# else
	sem_t semaphore;
	sem_t signalisation;
	# endif

	volatile int pointeur_lecture;
	volatile int pointeur_ecriture;
	pthread_t thread_signaux;
	volatile logical1 requete_arret;

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

	__EXTERN__ struct_queue_signaux *s_queue_signaux;
	__EXTERN__ int f_queue_signaux;

	# ifdef SEMAPHORES_NOMMES
	__EXTERN__ sem_t *semaphore_queue_signaux;
	__EXTERN__ sem_t *semaphore_signalisation;
# endif	# endif
# define PTHREAD_SCOPE_SYSTEM 0
#endif	#endif

#ifdef OS2	#ifdef OS2
Line 254 union semun	Line 358 union semun
};	};
#endif	#endif

	#ifndef RTLD_LOCAL
	# define RTLD_LOCAL 0
	#endif

	#ifndef SIGSTKSZ
	# define SIGSTKSZ 65536
	#endif

/*	/*
================================================================================	================================================================================
Line 266 union semun	Line 377 union semun
# define sem_destroy(a) sem_destroy_SysV(a)	# define sem_destroy(a) sem_destroy_SysV(a)
# define sem_wait(a) sem_wait_SysV(a)	# define sem_wait(a) sem_wait_SysV(a)
# define sem_trywait(a) sem_trywait_SysV(a)	# define sem_trywait(a) sem_trywait_SysV(a)
	# define sem_timedwait(a, b) sem_timedwait_SysV(a, b)
# define sem_post(a) sem_post_SysV(a)	# define sem_post(a) sem_post_SysV(a)
# define sem_getvalue(a, b) sem_getvalue_SysV(a, b)	# define sem_getvalue(a, b) sem_getvalue_SysV(a, b)
# define sem_open(...) sem_open_SysV(__VA_ARGS__)	# define sem_open(...) sem_open_SysV(__VA_ARGS__)
Line 286 union semun	Line 398 union semun
// SIGINT	// SIGINT
// SIGTSTP	// SIGTSTP
// SIGCONT	// SIGCONT
// SIGURG
// SIGPIPE	// SIGPIPE
	// SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
	// SIGHUP
// SIGALRM	// SIGALRM

// Arrêt par STOP	# define SIGTEST 255
# define SIGFSTOP SIGUSR1
// Démarrage d'un processus fils
# define SIGSTART SIGUSR2
// Injection de données
# define SIGINJECT SIGQUIT
// Arrêt général
# ifndef OpenBSD
// La libpthread d'OpenBSD utilise SIGPROF
# define SIGABORT SIGPROF
# else
# define SIGABORT SIGTHR
# endif
// Arrêt d'un processus fils depuis autre chose que STOP
# if defined(Darwin) \|\| defined(OpenBSD)
# define SIGFABORT SIGINFO
# else
# define SIGFABORT SIGPOLL
# endif

// Nombre d'interruptions disponibles	// Nombre d'interruptions disponibles
# define d_NOMBRE_INTERRUPTIONS 64	# define d_NOMBRE_INTERRUPTIONS 64
Line 351 union semun	Line 446 union semun

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

typedef FILE file;
typedef unsigned char t_8_bits;

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

/*
================================================================================
Variables globales	Variables globales
================================================================================	================================================================================
*/	*/
Line 375 typedef unsigned char t_8_bits;	Line 455 typedef unsigned char t_8_bits;
# define LONGUEUR_NOM_SEMAPHORE 64	# define LONGUEUR_NOM_SEMAPHORE 64
# endif	# endif

# ifndef MAIN_RPL	# ifdef SEMAPHORES_NOMMES
# ifdef _BROKEN_SIGINFO	# define __PTR__ *
extern int *fifos_signaux;
# endif

extern jmp_buf contexte;
extern jmp_buf contexte_initial;

# ifdef SEMAPHORES_NOMMES
extern pthread_mutex_t mutex_sem;
# endif

extern pthread_key_t semaphore_fork_processus_courant;

extern sem_t
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_liste_threads;

extern sem_t
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_gestionnaires_signaux;

extern sem_t
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_gestionnaires_signaux_atomique;

# ifdef SEMAPHORES_NOMMES
// 0 -> liste_threads
// 1 -> gestionnaire_signaux
// 2 -> gestionnaire_signaux_atomique
// 3 -> &((*s_etat_processus).semaphore_fork)
extern unsigned char noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];
extern sem_t *semaphores_nommes[4];
# endif
# else	# else
# ifdef _BROKEN_SIGINFO	# define __PTR__
int *fifos_signaux;	# endif
# endif

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

# ifdef SEMAPHORES_NOMMES	__EXTERN__ volatile int signal_test;
pthread_mutex_t mutex_sem = PTHREAD_MUTEX_INITIALIZER;
# endif

pthread_key_t semaphore_fork_processus_courant;	__EXTERN__ pid_t pid_processus_pere;

sem_t	# ifdef SEMAPHORES_NOMMES
# ifdef SEMAPHORES_NOMMES	__EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__;
*	# endif
# endif
semaphore_liste_threads;

sem_t	__EXTERN__ pthread_mutex_t mutex_liste_threads
# ifdef SEMAPHORES_NOMMES	__STATIC_MUTEX_INITIALIZATION__;
*	__EXTERN__ pthread_mutex_t mutex_gestionnaires_signaux_atomique
# endif	__STATIC_MUTEX_INITIALIZATION__;
semaphore_gestionnaires_signaux;	__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;

sem_t	__EXTERN__ sem_t __PTR__ semaphore_gestionnaires_signaux;
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_gestionnaires_signaux_atomique;

# ifdef SEMAPHORES_NOMMES	__EXTERN__ volatile int routine_recursive;
unsigned char noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];
sem_t *semaphores_nommes[4];
# endif
# endif
#endif	#endif

#ifdef SEMAPHORES_NOMMES	#ifdef SEMAPHORES_NOMMES
enum t_semaphore { sem_liste_threads = 0,	#define SEM_FORK 0
sem_gestionnaires_signaux = 1,	#define SEM_QUEUE 1
sem_gestionnaires_signaux_atomique = 2,	#define SEM_SIGNAUX 2
sem_fork = 3 };	#define SEM_SIGNALISATION 3
	sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);
sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore);	sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);
int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore);	int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);
	int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre);
int sem_getvalue2(sem_t semaphore, int valeur);	int sem_getvalue2(sem_t semaphore, int valeur);
	sem_t *sem_open2(pid_t pid, int ordre);

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

#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)	#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
#define sem_post(semaphore) \	#define sem_post(semaphore) \
Line 494 int sem_getvalue2(sem_t *semaphore, int	Line 535 int sem_getvalue2(sem_t *semaphore, int
#define ufprintf(flux, ...) transliterated_fprintf(NULL, \	#define ufprintf(flux, ...) transliterated_fprintf(NULL, \
flux, __VA_ARGS__)	flux, __VA_ARGS__)

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

#ifdef SunOS	#ifdef SunOS
# define fopen(...) ({ FILE *desc; \	# define fopen(...) ({ FILE *desc; \
while((desc = fopen(__VA_ARGS__)) == NULL) \	while((desc = fopen(__VA_ARGS__)) == NULL) \
Line 508 int sem_getvalue2(sem_t *semaphore, int	Line 545 int sem_getvalue2(sem_t *semaphore, int
# define fclose(...) ({ int ios; \	# define fclose(...) ({ int ios; \
while((ios = fclose(__VA_ARGS__)) != 0) \	while((ios = fclose(__VA_ARGS__)) != 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })	{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
# define fread(...) ({ int ios; \
while((ios = fread(__VA_ARGS__)) < 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
# define fflush(flux) ({ int ios; \	# define fflush(flux) ({ int ios; \
while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \	while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \
{ if ((errno != EINTR) && (errno != 0)) break; } ios; })	{ if ((errno != EINTR) && (errno != 0)) break; } ios; })
Line 786 pid_t debug_fork();	Line 820 pid_t debug_fork();
# define d_es_contexte __erreur(2013)	# define d_es_contexte __erreur(2013)
# define d_es_somme_controle __erreur(2014)	# define d_es_somme_controle __erreur(2014)
# define d_es_semaphore __erreur(2015)	# define d_es_semaphore __erreur(2015)
	# define d_es_mutex_acquis_autre_thread __erreur(2016)
#endif	#endif

/*	/*
Line 922 pid_t debug_fork();	Line 957 pid_t debug_fork();
# define d_ex_clef_inexistante __erreur(80)	# define d_ex_clef_inexistante __erreur(80)
# define d_ex_nom_implicite __erreur(81)	# define d_ex_nom_implicite __erreur(81)
# define d_ex_version_bibliotheque __erreur(82)	# define d_ex_version_bibliotheque __erreur(82)
	# define d_ex_creation_variable_globale __erreur(83)
	# define d_ex_erreur_interne_rplcas __erreur(84)
	# define d_ex_fichier_corrompu __erreur(85)
	# define d_ex_mutex_acquis_autre_thread __erreur(86)
	# define d_ex_expression_reguliere __erreur(87)
	# define d_ex_instruction_indisponible __erreur(88)
	# define d_ex_chiffrement __erreur(89)
	# define d_ex_chiffrement_indisponible __erreur(90)
	# define d_ex_longueur_clef_chiffrement __erreur(91)
	# define d_ex_taille_message __erreur(92)
#endif	#endif


Line 972 pid_t debug_fork();	Line 1017 pid_t debug_fork();
#define VIN __RPL_VIN	#define VIN __RPL_VIN
#define VRL __RPL_VRL	#define VRL __RPL_VRL

	enum t_rplcas_commandes { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };

enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,	enum t_type { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,	MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
Line 1108 typedef struct fichier	Line 1154 typedef struct fichier
typedef struct rpl_mutex	typedef struct rpl_mutex
{	{
pthread_mutex_t mutex;	pthread_mutex_t mutex;
	pthread_t tid;
} struct_mutex;	} struct_mutex;
#endif	#endif

Line 1181 typedef struct descripteur_fichier	Line 1228 typedef struct descripteur_fichier
pid_t pid;	pid_t pid;
pthread_t tid;	pthread_t tid;

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

Line 1215 typedef struct connecteur_sql	Line 1265 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 1228 typedef struct connecteur_sql	Line 1279 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 1277 typedef struct liste_chainee	Line 1332 typedef struct liste_chainee

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

	#define d_NOMBRE_SIGNAUX 64

	typedef struct gestion_signaux
	{
	unsigned char masque_signaux[d_NOMBRE_SIGNAUX];

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

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

	pthread_mutex_t mutex;
	} struct_gestion_signaux;

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

	__EXTERN__ volatile struct_gestion_signaux signaux_externes
	__STATIC_GESTION_SIGNAUX__;


	/*
	--------------------------------------------------------------------------------
Structure liste profilage	Structure liste profilage
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
Line 1378 typedef struct descripteur_thread	Line 1468 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 1402 typedef struct liste_pile_systeme	Line 1489 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 1441 typedef struct liste_pile_systeme	Line 1526 typedef struct liste_pile_systeme

/*	/*
type clôture :	type clôture :
C SELECT : END termine un test SELECT/DEFAULT/END.	C SELECT : END termine un test SELECT/DEFAULT/END.
D DO : END termine une boucle DO/UNTIL/END.	D DO : END termine une boucle DO/UNTIL/END.
I IF : END termine un test IF/THEN (ELSE)/END.	I IF : END termine un test IF/THEN (ELSE)/END.
J IFERR : END termine un test IFERR/THEN (ELSE)/END.	J IFERR : END termine un test IFERR/THEN (ELSE)/END.
K CASE : END termine un test CASE/THEN/END	K CASE : END termine un test CASE/THEN/END
W WHILE : END termine une boucle WHILE/REPEAT/END.	W WHILE : END termine une boucle WHILE/REPEAT/END.
	Q CRITICAL : END termine une section critique CRITICAL/END

F FOR : NEXT ou STEP termine une boucle avec compteur.	F FOR : NEXT ou STEP termine une boucle avec compteur.
S START : NEXT ou STEP termine une boucle sans compteur.	S START : NEXT ou STEP termine une boucle sans compteur.
L LOOP : boucle utilisé dans le traitement de l'instruction RETURN.	L LOOP : boucle utilisé dans le traitement de l'instruction RETURN.
Elle correspond à une boucle FOR ou START mais sans son	Elle correspond à une boucle FOR ou START mais sans son
initialisation.	initialisation.
	A FORALL : NEXT termine une boucle sur un objet.
*/	*/

unsigned long adresse_retour;	unsigned long adresse_retour;
unsigned long niveau_courant;	unsigned long niveau_courant;
	struct_liste_chainee *pointeur_objet_retour;
struct_objet *pointeur_adresse_retour;	struct_objet *pointeur_adresse_retour;
} struct_liste_pile_systeme;	} struct_liste_pile_systeme;
#endif	#endif
Line 1478 typedef union position_variable	Line 1566 typedef 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;	unsigned long niveau;

Line 1510 typedef struct variable_partage	Line 1598 typedef struct variable_partage
union_position_variable variable_partagee;	union_position_variable variable_partagee;

struct_objet *objet;	struct_objet *objet;
} struct_variable_partagee;

typedef struct table_variables_partagees
{
pthread_mutex_t mutex;

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

unsigned long position_variable;
} struct_table_variables_partagees;

#endif	#endif

Line 1670 typedef struct rpl_arguments	Line 1748 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_NORMAL); \
	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
	unsigned long niveau;

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

	logical1 variable_verrouillee;
	logical1 variable_masquee;
	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

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 1716 typedef struct processus	Line 1912 typedef struct processus

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

/* Requetes */	/* Requetes */

Line 1758 typedef struct processus	Line 1954 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];

# if !defined(Cygwin)	volatile int pointeur_signal_ecriture;
# if !(OpenBSD)	volatile int pointeur_signal_lecture;
stack_t pile_signal;	volatile enum signaux_rpl signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
# else	volatile logical1 demarrage_fils;
# ifdef SA_ONSTACK	volatile logical1 redemarrage_processus;
# undef SA_ONSTACK
# endif
# define SA_ONSTACK 0
# endif
# else
# define SA_ONSTACK 0
# define RTLD_LOCAL 0
# endif

/* Contextes */	/* Contextes */

Line 1780 typedef struct processus	Line 1970 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
	// l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau

	struct_arbre_variables *s_arbre_variables;
	struct_liste_variables *l_liste_variables_par_niveau;
	struct_liste_variables_statiques
	*l_liste_variables_statiques;

	struct_arbre_variables_partagees
	**s_arbre_variables_partagees;
	struct_liste_variables_partagees
	**l_liste_variables_partagees;

	logical1 niveau_supprime;

	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;

struct_table_variables_partagees	int *pointeurs_caracteres_variables;
*s_liste_variables_partagees;	int nombre_caracteres_variables;

unsigned long niveau_courant;	unsigned long niveau_courant;
unsigned long niveau_initial;	unsigned long niveau_initial;
unsigned long position_variable_courante;
unsigned long position_variable_statique_courante;

logical1 creation_variables_statiques;	logical1 creation_variables_statiques;
logical1 creation_variables_partagees;	logical1 creation_variables_partagees;
Line 2059 typedef struct processus	Line 2266 typedef struct processus
gsl_rng *generateur_aleatoire;	gsl_rng *generateur_aleatoire;
const gsl_rng_type *type_generateur_aleatoire;	const gsl_rng_type *type_generateur_aleatoire;

	void *contexte_cas;

integer8 nombre_arguments;	integer8 nombre_arguments;

/*	/*
Line 2081 typedef struct processus	Line 2290 typedef struct processus

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

logical1 processus_detache;	logical1 processus_detache;

Line 2096 typedef struct processus	Line 2306 typedef struct processus
pthread_mutex_t mutex;	pthread_mutex_t mutex;
pthread_mutex_t mutex_allocation;	pthread_mutex_t mutex_allocation;

// Sémaphore autorisant les fork()	// Mutex autorisant les fork()
sem_t	sem_t __PTR__ semaphore_fork;
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_fork;

/* Mutexes */	/* Mutexes */

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

	/* Drapeau nécessaire à RESTART */

	volatile logical1 requete_redemarrage;

/* Gestion optimisée de la mémoire */	/* Gestion optimisée de la mémoire */

Line 2121 typedef struct processus	Line 2332 typedef struct processus
unsigned long taille_pile_objets;	unsigned long taille_pile_objets;
struct_objet *pile_objets;	struct_objet *pile_objets;

# ifndef DEBUG_MALLOC	# define TAILLE_CACHE 16384
# define TAILLE_CACHE 16384
# else
# define TAILLE_CACHE 4
# endif

unsigned long *objets_adr[TAILLE_CACHE];	unsigned long *objets_adr[TAILLE_CACHE];
int pointeur_adr;	int pointeur_adr;
Line 2159 typedef struct processus	Line 2366 typedef struct processus

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

/*	struct_arbre_variables *variables_noeud[TAILLE_CACHE];
--------------------------------------------------------------------------------	int pointeur_variables_noeud;
Structures instruction intrinsèque
--------------------------------------------------------------------------------
*/

#ifndef RPLARGS	struct_arbre_variables_partagees
typedef struct instruction	*variables_partagees_noeud[TAILLE_CACHE];
{	int pointeur_variables_partagees_noeud;
struct instruction **noeud;
void (feuille)(struct_processus );	struct_liste_variables *variables_feuille[TAILLE_CACHE];
} struct_instruction;	int pointeur_variables_feuille;

	struct_variable *variables_variable[TAILLE_CACHE];
	int pointeur_variables_variable;

	struct_arbre_variables **variables_tableau_noeuds[TAILLE_CACHE];
	int pointeur_variables_tableau_noeuds;

	struct_arbre_variables_partagees
	**variables_tableau_noeuds_partages
	[TAILLE_CACHE];
	int pointeur_variables_tableau_noeuds_partages;
	} struct_processus;
#endif	#endif


/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Structure fonction	Structure fonction
Line 2212 typedef struct fonction	Line 2425 typedef struct fonction
// BEGIN C PROTOTYPES	// BEGIN C PROTOTYPES
void instruction_sensible_e(struct_processus *s_etat_processus);	void instruction_sensible_e(struct_processus *s_etat_processus);
void instruction_sensible_i(struct_processus *s_etat_processus);	void instruction_sensible_i(struct_processus *s_etat_processus);
	void instruction_sensible_infinity(struct_processus *s_etat_processus);

void instruction_abort(struct_processus *s_etat_processus);	void instruction_abort(struct_processus *s_etat_processus);
void instruction_abs(struct_processus *s_etat_processus);	void instruction_abs(struct_processus *s_etat_processus);
Line 2247 void instruction_ceil(struct_processus *	Line 2461 void instruction_ceil(struct_processus *
void instruction_centr(struct_processus *s_etat_processus);	void instruction_centr(struct_processus *s_etat_processus);
void instruction_cf(struct_processus *s_etat_processus);	void instruction_cf(struct_processus *s_etat_processus);
void instruction_chr(struct_processus *s_etat_processus);	void instruction_chr(struct_processus *s_etat_processus);
	void instruction_cipher(struct_processus *s_etat_processus);
void instruction_clear(struct_processus *s_etat_processus);	void instruction_clear(struct_processus *s_etat_processus);
void instruction_cllcd(struct_processus *s_etat_processus);	void instruction_cllcd(struct_processus *s_etat_processus);
void instruction_clmf(struct_processus *s_etat_processus);	void instruction_clmf(struct_processus *s_etat_processus);
Line 2281 void instruction_cosh(struct_processus *	Line 2496 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 2306 void instruction_detach(struct_processus	Line 2522 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 2365 void instruction_fleche_str(struct_proce	Line 2582 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 2408 void instruction_in(struct_processus *s_	Line 2626 void instruction_in(struct_processus *s_
void instruction_incr(struct_processus *s_etat_processus);	void instruction_incr(struct_processus *s_etat_processus);
void instruction_indep(struct_processus *s_etat_processus);	void instruction_indep(struct_processus *s_etat_processus);
void instruction_input(struct_processus *s_etat_processus);	void instruction_input(struct_processus *s_etat_processus);
	void instruction_infinity(struct_processus *s_etat_processus);
void instruction_inquire(struct_processus *s_etat_processus);	void instruction_inquire(struct_processus *s_etat_processus);
void instruction_int(struct_processus *s_etat_processus);	void instruction_int(struct_processus *s_etat_processus);
void instruction_interrupt(struct_processus *s_etat_processus);	void instruction_interrupt(struct_processus *s_etat_processus);
Line 2431 void instruction_lcd_fleche(struct_proce	Line 2650 void instruction_lcd_fleche(struct_proce
void instruction_lchol(struct_processus *s_etat_processus);	void instruction_lchol(struct_processus *s_etat_processus);
void instruction_le(struct_processus *s_etat_processus);	void instruction_le(struct_processus *s_etat_processus);
void instruction_legv(struct_processus *s_etat_processus);	void instruction_legv(struct_processus *s_etat_processus);
	void instruction_limit(struct_processus *s_etat_processus);
void instruction_line(struct_processus *s_etat_processus);	void instruction_line(struct_processus *s_etat_processus);
void instruction_list_fleche(struct_processus *s_etat_processus);	void instruction_list_fleche(struct_processus *s_etat_processus);
void instruction_ln(struct_processus *s_etat_processus);	void instruction_ln(struct_processus *s_etat_processus);
Line 2499 void instruction_pmax(struct_processus *	Line 2719 void instruction_pmax(struct_processus *
void instruction_pmin(struct_processus *s_etat_processus);	void instruction_pmin(struct_processus *s_etat_processus);
void instruction_poke(struct_processus *s_etat_processus);	void instruction_poke(struct_processus *s_etat_processus);
void instruction_polar(struct_processus *s_etat_processus);	void instruction_polar(struct_processus *s_etat_processus);
	void instruction_poll(struct_processus *s_etat_processus);
void instruction_pos(struct_processus *s_etat_processus);	void instruction_pos(struct_processus *s_etat_processus);
void instruction_pourcent(struct_processus *s_etat_processus);	void instruction_pourcent(struct_processus *s_etat_processus);
void instruction_pourcent_ch(struct_processus *s_etat_processus);	void instruction_pourcent_ch(struct_processus *s_etat_processus);
Line 2555 void instruction_read(struct_processus *	Line 2776 void instruction_read(struct_processus *
void instruction_recode(struct_processus *s_etat_processus);	void instruction_recode(struct_processus *s_etat_processus);
void instruction_recv(struct_processus *s_etat_processus);	void instruction_recv(struct_processus *s_etat_processus);
void instruction_redraw(struct_processus *s_etat_processus);	void instruction_redraw(struct_processus *s_etat_processus);
	void instruction_regex(struct_processus *s_etat_processus);
void instruction_relax(struct_processus *s_etat_processus);	void instruction_relax(struct_processus *s_etat_processus);
void instruction_remove(struct_processus *s_etat_processus);	void instruction_remove(struct_processus *s_etat_processus);
void instruction_res(struct_processus *s_etat_processus);	void instruction_res(struct_processus *s_etat_processus);
	void instruction_restart(struct_processus *s_etat_processus);
void instruction_recall(struct_processus *s_etat_processus);	void instruction_recall(struct_processus *s_etat_processus);
void instruction_regv(struct_processus *s_etat_processus);	void instruction_regv(struct_processus *s_etat_processus);
void instruction_repeat(struct_processus *s_etat_processus);	void instruction_repeat(struct_processus *s_etat_processus);
Line 2623 void instruction_sqlquery(struct_process	Line 2846 void instruction_sqlquery(struct_process
void instruction_sqrt(struct_processus *s_etat_processus);	void instruction_sqrt(struct_processus *s_etat_processus);
void instruction_sr(struct_processus *s_etat_processus);	void instruction_sr(struct_processus *s_etat_processus);
void instruction_srb(struct_processus *s_etat_processus);	void instruction_srb(struct_processus *s_etat_processus);
	void instruction_srev(struct_processus *s_etat_processus);
void instruction_sst(struct_processus *s_etat_processus);	void instruction_sst(struct_processus *s_etat_processus);
void instruction_star_d(struct_processus *s_etat_processus);	void instruction_star_d(struct_processus *s_etat_processus);
void instruction_star_h(struct_processus *s_etat_processus);	void instruction_star_h(struct_processus *s_etat_processus);
Line 2684 void instruction_t_vers_l(struct_process	Line 2908 void instruction_t_vers_l(struct_process

void instruction_ucase(struct_processus *s_etat_processus);	void instruction_ucase(struct_processus *s_etat_processus);
void instruction_uchol(struct_processus *s_etat_processus);	void instruction_uchol(struct_processus *s_etat_processus);
void instruction_undo(struct_processus *s_etat_processus);
void instruction_unlock(struct_processus *s_etat_processus);	void instruction_unlock(struct_processus *s_etat_processus);
void instruction_unprotect(struct_processus *s_etat_processus);	void instruction_unprotect(struct_processus *s_etat_processus);
void instruction_until(struct_processus *s_etat_processus);	void instruction_until(struct_processus *s_etat_processus);
Line 2739 void affichage_pile(struct_processus *s_	Line 2962 void affichage_pile(struct_processus *s_
niveau_courant);	niveau_courant);
#endif	#endif

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

#ifndef RPLARGS	#ifndef RPLARGS
Line 2751 void appel_gnuplot(struct_processus *s_e	Line 2973 void appel_gnuplot(struct_processus *s_e
void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);	void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
void cond(struct_processus *s_etat_processus,	void cond(struct_processus *s_etat_processus,
struct_matrice s_matrice, real8 condition);	struct_matrice s_matrice, real8 condition);
	void conversion_chaine(struct_processus *s_etat_processus,
	unsigned char *chaine, unsigned char type);
void conversion_decimal_vers_hms(real8 *angle);	void conversion_decimal_vers_hms(real8 *angle);
void conversion_degres_vers_radians(real8 *angle);	void conversion_degres_vers_radians(real8 *angle);
void conversion_element_tex(unsigned char *element, unsigned char fonction);	void conversion_element_tex(unsigned char *element, unsigned char fonction);
Line 2760 void conversion_hms_vers_decimal(real8 *	Line 2984 void conversion_hms_vers_decimal(real8 *
void conversion_majuscule_limitee(unsigned char *chaine_entree,	void conversion_majuscule_limitee(unsigned char *chaine_entree,
unsigned char *chaine_sortie, unsigned long longueur);	unsigned char *chaine_sortie, unsigned long longueur);
void conversion_radians_vers_degres(real8 *angle);	void conversion_radians_vers_degres(real8 *angle);
	void copie_arbre_variables(struct_processus *s_etat_processus,
	struct_processus *s_nouvel_etat_processus);
void correction_formateur_tex(struct_processus *s_etat_processus,	void correction_formateur_tex(struct_processus *s_etat_processus,
unsigned char **ligne);	unsigned char **ligne);
void depilement_pile_systeme(struct_processus *s_etat_processus);	void depilement_pile_systeme(struct_processus *s_etat_processus);
Line 2799 void impression_tex(struct_processus *s_	Line 3025 void impression_tex(struct_processus *s_
void informations(struct_processus *s_etat_processus);	void informations(struct_processus *s_etat_processus);
void initialisation_allocateur(struct_processus *s_etat_processus);	void initialisation_allocateur(struct_processus *s_etat_processus);
void initialisation_completion(void);	void initialisation_completion(void);
	void initialisation_contexte_cas(struct_processus *s_etat_processus);
void initialisation_drapeaux(struct_processus *s_etat_processus);	void initialisation_drapeaux(struct_processus *s_etat_processus);
void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,	void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,
logical1 initialisation_automatique, unsigned long int racine);	logical1 initialisation_automatique, unsigned long int racine);
void initialisation_instructions(struct_processus *s_etat_processus);	void initialisation_instructions(struct_processus *s_etat_processus);
	void initialisation_variables(struct_processus *s_etat_processus);
#endif	#endif

void initialisation_objet(struct_objet *s_objet);	void initialisation_objet(struct_objet *s_objet);
Line 2815 void insertion_thread_surveillance(struc	Line 3043 void insertion_thread_surveillance(struc
void integrale_romberg(struct_processus *s_etat_processus,	void integrale_romberg(struct_processus *s_etat_processus,
struct_objet s_expression, unsigned char variable,	struct_objet s_expression, unsigned char variable,
real8 a, real8 b, real8 precision);	real8 a, real8 b, real8 precision);
void interruption1(SIGHANDLER_ARGS);	void interface_cas(struct_processus *s_etat_processus,
void interruption2(SIGHANDLER_ARGS);	enum t_rplcas_commandes commande);
void interruption3(SIGHANDLER_ARGS);	void interruption1(int signal);
void interruption4(SIGHANDLER_ARGS);	void interruption2(int signal);
void interruption5(SIGHANDLER_ARGS);	void interruption3(int signal);
void interruption6(SIGHANDLER_ARGS);	void interruption4(int signal);
void interruption7(SIGHANDLER_ARGS);	void interruption5(int signal);
void interruption8(SIGHANDLER_ARGS);	void interruption6(int signal);
void interruption9(SIGHANDLER_ARGS);	void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);
void interruption10(SIGHANDLER_ARGS);
void interruption11(SIGHANDLER_ARGS);
void inversion_matrice(struct_processus *s_etat_processus,	void inversion_matrice(struct_processus *s_etat_processus,
struct_matrice *s_matrice);	struct_matrice *s_matrice);
void lancement_daemon(struct_processus *s_etat_processus);	void lancement_daemon(struct_processus *s_etat_processus);
Line 2840 void liberation_maillon(struct_processus	Line 3066 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 2856 void retrait_thread(struct_processus *s_	Line 3089 void retrait_thread(struct_processus *s_
void retrait_thread_surveillance(struct_processus *s_etat_processus,	void retrait_thread_surveillance(struct_processus *s_etat_processus,
struct_descripteur_thread *s_argument_thread);	struct_descripteur_thread *s_argument_thread);
void rplcore(struct_processus *s_etat_processus);	void rplcore(struct_processus *s_etat_processus);
	#endif

void scrutation_injection(struct_processus *s_etat_processus);	void scrutation_injection(struct_processus *s_etat_processus);

	#ifndef RPLARGS
	void scrutation_interruptions(struct_processus *s_etat_processus);
void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);	void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
void surveillance_processus(void argument);	void surveillance_processus(void argument);
void swap(void variable_1, void variable_2, unsigned long taille_octets);	void swap(void variable_1, void variable_2, unsigned long taille_octets);
	void thread_signaux(void argument);
void trace(struct_processus s_etat_processus, FILE flux);	void trace(struct_processus s_etat_processus, FILE flux);
void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);	void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);
void traitement_exceptions_gsl(const char reason, const char file,	void traitement_exceptions_gsl(const char reason, const char file,
Line 2884 void valeurs_singulieres(struct_processu	Line 3123 void valeurs_singulieres(struct_processu
void verrouillage_threads_concurrents(struct_processus *s_etat_processus);	void verrouillage_threads_concurrents(struct_processus *s_etat_processus);
#endif	#endif

	/*
	--------------------------------------------------------------------------------
	Fonctions de gestion des signaux
	--------------------------------------------------------------------------------
	*/

#ifndef RPLARGS	#ifndef RPLARGS
#ifdef _BROKEN_SIGINFO	void creation_queue_signaux(struct_processus *s_etat_processus);
void creation_fifos_signaux(struct_processus *s_etat_processus);	void liberation_queue_signaux(struct_processus *s_etat_processus);
void destruction_fifos_signaux(struct_processus *s_etat_processus);	void destruction_queue_signaux(struct_processus *s_etat_processus);
void liberation_fifos_signaux(struct_processus *s_etat_processus);	int envoi_signal_contexte(struct_processus *s_etat_processus,
#endif	enum signaux_rpl signal);
	int envoi_signal_processus(pid_t pid, enum signaux_rpl signal);
	int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);
#endif	#endif

/*	/*
Line 2910 complex16 sommation_vecteur_complexe(com	Line 3157 complex16 sommation_vecteur_complexe(com
*/	*/

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

/*	/*
Line 2968 struct_liste_chainee *sauvegarde_argumen	Line 3216 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, long longueur);
	unsigned char chiffrement(const EVP_CIPHER type_chiffrement,
	logical1 encodage, unsigned char *message, unsigned int
	longueur_message, unsigned char *clef, unsigned int longueur_clef,
	unsigned char *vecteur_initialisation,
	unsigned int *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 *date_compilation();
unsigned char extraction_chaine(unsigned char chaine, unsigned long i,	unsigned char extraction_chaine(unsigned char chaine, unsigned long i,
unsigned long j);	unsigned long j);
unsigned char formateur(struct_processus s_etat_processus, long offset,	unsigned char formateur(struct_processus s_etat_processus, long offset,
Line 2982 unsigned char *formateur_fichier(struct_	Line 3236 unsigned char *formateur_fichier(struct_
struct_objet s_objet, struct_objet s_format,	struct_objet s_objet, struct_objet s_format,
long longueur, long longueur_champ, unsigned char format,	long longueur, long longueur_champ, unsigned char format,
unsigned char type, long longueur_effective, long recursivite);	unsigned char type, long longueur_effective, long recursivite);
	unsigned char formateur_flux(struct_processus s_etat_processus,
	unsigned char donnees, long longueur);
unsigned char formateur_fichier_nombre(struct_processus s_etat_processus,	unsigned char formateur_fichier_nombre(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ, unsigned char format);	long longueur, long longueur_champ, unsigned char format);
	unsigned char *formateur_fichier_binaire_nombre(struct_processus
	s_etat_processus, void valeur_numerique, unsigned char type,
	long longueur, long *longueur_conversion);
unsigned char formateur_fichier_reel(struct_processus s_etat_processus,	unsigned char formateur_fichier_reel(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ, unsigned char format);	long longueur, long longueur_champ, unsigned char format);
Line 2993 unsigned char *formateur_nombre(struct_p	Line 3252 unsigned char *formateur_nombre(struct_p
unsigned char formateur_reel(struct_processus s_etat_processus,	unsigned char formateur_reel(struct_processus s_etat_processus,
void *valeur_numerique, unsigned char type);	void *valeur_numerique, unsigned char type);
unsigned char messages(struct_processus s_etat_processus);	unsigned char messages(struct_processus s_etat_processus);
	unsigned char pointeur_ieme_caractere(struct_processus s_etat_processus,
	unsigned char *chaine, integer8 position);
unsigned char purification_chaine(unsigned char chaine);	unsigned char purification_chaine(unsigned char chaine);
	unsigned char *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 3010 unsigned char *transliteration(struct_pr	Line 3273 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 3038 logical1 initialisation_fichier_acces_di	Line 3304 logical1 initialisation_fichier_acces_di
sqlite3 *sqlite, logical1 binaire);	sqlite3 *sqlite, logical1 binaire);
logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,	logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
sqlite3 *sqlite, integer8 position_clef, logical1 binaire);	sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
	logical1 lancement_thread_signaux(struct_processus *s_etat_processus);
logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);	logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);
logical1 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 3066 logical1 ecriture_pipe(struct_processus	Line 3337 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 3098 ssize_t write_atomic(struct_processus *s	Line 3366 ssize_t write_atomic(struct_processus *s
*/	*/

int alsprintf(unsigned char *strp, const char fmt, ...);	int alsprintf(unsigned char *strp, const char fmt, ...);
	int interruption_violation_access(void *adresse_fautive, int gravite);
	#ifndef RPLARGS
	int liste_variables(struct_processus *s_etat_processus,
	struct_tableau_variables *tableau);
	int 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 3114 int wrapper_instruction_intrinseque(void	Line 3390 int wrapper_instruction_intrinseque(void

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

/*	/*
Line 3135 logical8 masque_entiers_binaires(struct_	Line 3410 logical8 masque_entiers_binaires(struct_

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

/*	/*
Line 3179 struct_descripteur_fichier *descripteur_	Line 3458 struct_descripteur_fichier *descripteur_
struct_objet copie_objet(struct_processus s_etat_processus,	struct_objet copie_objet(struct_processus s_etat_processus,
struct_objet *s_objet, unsigned char type);	struct_objet *s_objet, unsigned char type);

	struct_objet allocation(struct_processus s_etat_processus, enum t_type type);
#ifndef RPLARGS	#ifndef RPLARGS
struct_objet formateur_date(struct_processus s_etat_processus,	struct_objet formateur_date(struct_processus s_etat_processus,
struct timeval *temps);	struct timeval *temps);
Line 3187 struct_objet *parametres_sql(struct_proc	Line 3467 struct_objet *parametres_sql(struct_proc
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);

	struct_arbre_variables allocation_noeud(struct_processus s_etat_processus);
	struct_arbre_variables **allocation_tableau_noeuds(
	struct_processus *s_etat_processus);

	/*
	--------------------------------------------------------------------------------
	Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques
	ou *struct_liste_variables_partagees
	--------------------------------------------------------------------------------
	*/

	struct_liste_variables_statiques *recherche_variable_statique(struct_processus
	s_etat_processus, unsigned char nom_variable,
	union_position_variable position, unsigned char origine);
	struct_liste_variables_partagees *recherche_variable_partagee(struct_processus
	s_etat_processus, unsigned char nom_variable,
	union_position_variable position, unsigned char origine);
#endif	#endif

/*	/*
Line 3241 void f77multiplicationci_(complex16 *ca,	Line 3539 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);

CVSweb interface <joel.bertrand@systella.fr>

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