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.8 and 1.119

version 1.8, 2010/02/10 10:14:26	version 1.119, 2011/09/10 20:45:07
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.11	RPL/2 (R) version 4.1.3
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

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

Line 22	Line 22

#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

	#ifndef __RPLCAS
	# ifdef Darwin
	# define _DARWIN_C_SOURCE
	# endif

	# ifdef OpenBSD
	# define _BSD_SOURCE
	# endif
	#endif

	#ifdef OS2
	# ifndef __RPLCAS
	# define _BSD_SOURCE
	# define _XOPEN_SOURCE 600
	# 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


/*	/*
================================================================================	================================================================================
Line 37	Line 71
#include <strings.h>	#include <strings.h>
#include <syslog.h>	#include <syslog.h>
#include <errno.h>	#include <errno.h>
	#include <stdarg.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 56	Line 92
# include <dlfcn.h>	# include <dlfcn.h>
# include <fcntl.h>	# include <fcntl.h>
# include <pthread.h>	# include <pthread.h>

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

# include <pwd.h>	# include <pwd.h>
# include <semaphore.h>
	# ifdef _BROKEN_SIGINFO
	# include <sys/ipc.h>
	# 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
	typedef struct
	{
	int sem;
	unsigned char *path;
	pid_t pid;
	} sem_t;
	# endif

	# define SEM_FAILED NULL

	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_post_SysV(sem_t *sem);
	int sem_getvalue_SysV(sem_t sem, int value);
	int sem_unlink_SysV(const char *nom);
	int sem_destroy_SysV(sem_t *sem);
	# endif

# include <setjmp.h>	# include <setjmp.h>
# include <signal.h>	# include <signal.h>
# include <termios.h>	# include <termios.h>
Line 70	Line 160
# include "termcap.h"	# include "termcap.h"
# include "iconv.h"	# include "iconv.h"

	# include "openssl/evp.h"
	# include "sqlite3.h"

# define HAVE_INLINE	# define HAVE_INLINE
# define GSL_RANGE_CHECK_OFF	# define GSL_RANGE_CHECK_OFF
# include "gsl/gsl_cdf.h"	# include "gsl/gsl_cdf.h"
Line 86	Line 179
# 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 100	Line 198
# 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	#endif

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

	#ifdef _BROKEN_SIGINFO
	# 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

	int kill_broken_siginfo(pid_t pid, int signal);
	int pthread_kill_broken_siginfo(pthread_t tid, int signal);
	pid_t origine_signal(int signal);
	int queue_in(pid_t pid, int signal);
	#else
	# define SIGHANDLER_ARGS int signal, siginfo_t siginfo, void context
	#endif

	#ifdef OpenBSD
	# ifdef PTHREAD_SCOPE_SYSTEM
	# undef PTHREAD_SCOPE_SYSTEM
	# endif
	# define PTHREAD_SCOPE_SYSTEM 0
	#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


	/*
	================================================================================
	SÉMAPHORES
	================================================================================
	*/

	#ifdef IPCS_SYSV
	# define sem_init(a, b, c) sem_init_SysV(a, b, c)
	# define sem_destroy(a) sem_destroy_SysV(a)
	# define sem_wait(a) sem_wait_SysV(a)
	# define sem_trywait(a) sem_trywait_SysV(a)
	# define sem_post(a) sem_post_SysV(a)
	# 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)
	#endif


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

#ifndef RPLARGS	#ifndef RPLARGS

	// Signaux utilisés par défaut :
	// SIGINT
	// SIGTSTP
	// SIGCONT
	// SIGURG
	// SIGPIPE
	// SIGALRM

	// Arrêt par STOP
# define SIGFSTOP SIGUSR1	# define SIGFSTOP SIGUSR1
	// Démarrage d'un processus fils
# define SIGSTART SIGUSR2	# define SIGSTART SIGUSR2
	// Injection de données
# define SIGINJECT SIGQUIT	# define SIGINJECT SIGQUIT
# define SIGABORT SIGPROF	// 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) \|\| defined(NetBSD)
	# define SIGFABORT SIGINFO
	# else
	# define SIGFABORT SIGPOLL
	# endif

	# define SIGTEST SIGILL

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

Line 163 typedef FILE file;	Line 368 typedef FILE file;
typedef unsigned char t_8_bits;	typedef unsigned char t_8_bits;

#ifndef RPLARGS	#ifndef RPLARGS
# include "rpltypes.conv.h"	# include "rpltypes-conv.h"
#else	#else
# include "rpltypes.h"	# include "rpltypes.h"
#endif	#endif
Line 175 typedef unsigned char t_8_bits;	Line 380 typedef unsigned char t_8_bits;
*/	*/

#ifndef RPLARGS	#ifndef RPLARGS
	# ifdef SEMAPHORES_NOMMES
	# define LONGUEUR_NOM_SEMAPHORE 64
	# endif

# ifndef MAIN_RPL	# ifndef MAIN_RPL
extern jmp_buf contexte;	# ifdef _BROKEN_SIGINFO
extern jmp_buf contexte_initial;	extern int *fifos_signaux;
	# endif

	extern jmp_buf contexte;
	extern jmp_buf contexte_initial;
	extern jmp_buf contexte_processus;
	extern jmp_buf contexte_thread;

extern pthread_key_t semaphore_fork_processus_courant;	extern int signal_test;

extern sem_t semaphore_liste_threads;	extern pid_t pid_processus_pere;
extern sem_t semaphore_gestionnaires_signaux;
extern sem_t semaphore_gestionnaires_signaux_atomique;	# 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
jmp_buf contexte;	# ifdef _BROKEN_SIGINFO
jmp_buf contexte_initial;	int *fifos_signaux;
	# endif

	jmp_buf contexte;
	jmp_buf contexte_initial;
	jmp_buf contexte_processus;
	jmp_buf contexte_thread;

	int signal_test;

	pid_t pid_processus_pere;

	# ifdef SEMAPHORES_NOMMES
	pthread_mutex_t mutex_sem = PTHREAD_MUTEX_INITIALIZER;
	# endif

pthread_key_t semaphore_fork_processus_courant;	pthread_key_t semaphore_fork_processus_courant;

	sem_t
	# ifdef SEMAPHORES_NOMMES
	*
	# endif
	semaphore_liste_threads;

	sem_t
	# ifdef SEMAPHORES_NOMMES
	*
	# endif
	semaphore_gestionnaires_signaux;

	sem_t
	# ifdef SEMAPHORES_NOMMES
	*
	# endif
	semaphore_gestionnaires_signaux_atomique;

sem_t semaphore_liste_threads;	# ifdef SEMAPHORES_NOMMES
sem_t semaphore_gestionnaires_signaux;	unsigned char noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];
sem_t semaphore_gestionnaires_signaux_atomique;	sem_t *semaphores_nommes[4];
	# endif
# endif	# endif
#endif	#endif

	#ifdef SEMAPHORES_NOMMES
	enum t_semaphore { sem_liste_threads = 0,
	sem_gestionnaires_signaux = 1,
	sem_gestionnaires_signaux_atomique = 2,
	sem_fork = 3 };

	sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore);
	int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore);
	int sem_getvalue2(sem_t semaphore, int valeur);

	#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

/*	/*
================================================================================	================================================================================
Macros	Macros
Line 222 typedef unsigned char t_8_bits;	Line 523 typedef unsigned char t_8_bits;
# 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; })
Line 260 typedef unsigned char t_8_bits;	Line 564 typedef unsigned char t_8_bits;

// 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
Line 270 typedef unsigned char t_8_bits;	Line 574 typedef unsigned char t_8_bits;
# define abs(i) (((i) >= 0) ? (i) : (-i))	# define abs(i) (((i) >= 0) ? (i) : (-i))
#endif	#endif

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

	#ifdef __GLIBC__
	#include <execinfo.h>
	#define __BACKTRACE
#define BACKTRACE(n) \	#define BACKTRACE(n) \
do \	do \
{ \	{ \
Line 291 typedef unsigned char t_8_bits;	Line 601 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 300 typedef unsigned char t_8_bits;	Line 610 typedef unsigned char t_8_bits;
fflush(stdout); \	fflush(stdout); \
pthread_mutex_unlock(&mutex); \	pthread_mutex_unlock(&mutex); \
} while(0)	} while(0)
	#else
	#define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
	#endif

#define NOTICE(m) \	#ifdef __BACKTRACE
do \	# define BUG(b, ...) \
{ \	do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
ufprintf(stderr, "[%d-%llu] %s() from %s at line %d: %s\n", \	(int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
getpid(), pthread_self(), __FUNCTION__, __FILE__, __LINE__, \	__VA_ARGS__; fflush(stdout); \
m); \	BACKTRACE(64); \
fflush(stderr); \	pthread_kill(pthread_self(), SIGBUS); }} while(0)
} 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 317 typedef unsigned char t_8_bits;	Line 636 typedef unsigned char t_8_bits;
================================================================================	================================================================================
*/	*/

	#ifdef DEBUG_MEMOIRE
	void analyse_post_mortem();
	void debug_memoire_ajout(size_t taille, const unsigned char fonction,
	unsigned long ligne, const unsigned char *argument);
	void debug_memoire_initialisation();
	void debug_memoire_modification(void pointeur, size_t taille,
	const unsigned char *fonction, unsigned long ligne,
	const unsigned char *argument);
	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 free(s) debug_memoire_retrait(s)
	#define realloc(s, t) debug_memoire_modification(s, t, \
	__FUNCTION__, __LINE__, #t)
	#define fork() debug_fork()
	#endif

#ifdef DEBUG_RETURN	#ifdef DEBUG_RETURN
#define return uprintf("[%d] Return from <%s()> at line #%d " \	#define return uprintf("[%d] Return from <%s()> at line #%d " \
"(%s [%d])\n", (int) getpid(), __FUNCTION__, \	"(%s [%d])\n", (int) getpid(), __FUNCTION__, \
__LINE__, strerror(errno), errno); fflush(stdout); errno=0; return	__LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return
#endif	#endif

#ifdef DEBUG_MUTEX	#ifdef DEBUG_MUTEX
Line 354 typedef unsigned char t_8_bits;	Line 693 typedef unsigned char t_8_bits;
if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })	if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
#endif	#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 388 typedef unsigned char t_8_bits;	Line 712 typedef unsigned char t_8_bits;
#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 442 typedef unsigned char t_8_bits;	Line 767 typedef unsigned char t_8_bits;
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

#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 __erreur(2014)
	# define d_es_semaphore __erreur(2015)
#endif	#endif

/*	/*
Line 470 typedef unsigned char t_8_bits;	Line 817 typedef unsigned char t_8_bits;

#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 491 typedef unsigned char t_8_bits;	Line 838 typedef unsigned char t_8_bits;

#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

/*	/*
Line 514 typedef unsigned char t_8_bits;	Line 861 typedef unsigned char t_8_bits;
// -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)
*/

#ifndef RPLARGS
# define d_os 4000
# define d_os_ligne_de_commande 4001
# define d_os_fichier_introuvable 4002
#endif	#endif


/*	/*
================================================================================	================================================================================
STRUCTURES	STRUCTURES
Line 618 typedef unsigned char t_8_bits;	Line 960 typedef unsigned char t_8_bits;
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	#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 };
Line 820 typedef struct descripteur_fichier	Line 1199 typedef struct descripteur_fichier
unsigned long identifiant;	unsigned long 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;	file *descripteur_c;
	sqlite3 *descripteur_sqlite;
} struct_descripteur_fichier;	} struct_descripteur_fichier;
#endif	#endif

Line 996 typedef struct descripteur_thread	Line 1377 typedef struct descripteur_thread

struct_objet *argument;	struct_objet *argument;

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

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 1082 typedef struct liste_pile_systeme	Line 1465 typedef struct liste_pile_systeme

/*	/*
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.
S START : NEXT ou STEP termine une boucle sans compteur.	F FOR : NEXT ou STEP termine une boucle avec compteur.
L LOOP : boucle utilisé dans le traitement de l'instruction RETURN.	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	Elle correspond à une boucle FOR ou START mais sans son
initialisation.	initialisation.
*/	*/

unsigned long adresse_retour;	unsigned long adresse_retour;
unsigned long niveau_courant;	unsigned long niveau_courant;
	struct_objet *pointeur_adresse_retour;
} struct_liste_pile_systeme;	} struct_liste_pile_systeme;
#endif	#endif

Line 1309 typedef struct rpl_arguments	Line 1694 typedef struct rpl_arguments
void *s_etat_processus;	void *s_etat_processus;
} struct_rpl_arguments;	} struct_rpl_arguments;

	/*
	--------------------------------------------------------------------------------
	Structure d'arbre des instructions intrinsèques
	--------------------------------------------------------------------------------
	*/

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

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

	#ifndef RPLARGS
	typedef struct arbre_variables
	{
	unsigned int noeuds_utilises;
	signed int indice_tableau_pere;
	struct arbre_variables *noeud_pere;
	struct arbre_variables **noeuds;
	struct liste_variables *feuille;
	} struct_arbre_variables;

	typedef struct tableau_variables
	{
	unsigned char origine;
	unsigned char *nom; // pointeur sur la struct_variable
	// réelle et non copie de la chaîne
	unsigned long niveau;

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

	logical1 variable_verrouillee;
	union_position_variable variable_statique;
	union_position_variable variable_partagee;
	} struct_tableau_variables;

	typedef struct liste_variables
	{
	union
	{
	// Utilisation dans la gestion des variables
	struct_variable *variable;
	// Utilisation dans la pile système (variables par niveau)
	struct_liste_chainee *liste;
	};

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

	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 1334 typedef struct processus	Line 1781 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 1345 typedef struct processus	Line 1793 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;	unsigned long position_courante;
unsigned long longueur_definitions_chainees;	unsigned long longueur_definitions_chainees;
Line 1353 typedef struct processus	Line 1802 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 1396 typedef struct processus	Line 1845 typedef struct processus
pthread_t thread_fusible;	pthread_t thread_fusible;
pthread_t thread_surveille_par_fusible;	pthread_t thread_surveille_par_fusible;

stack_t pile_signal;	# if !defined(Cygwin)
	# if !(OpenBSD)
	stack_t pile_signal;
	# else
	# ifdef SA_ONSTACK
	# undef SA_ONSTACK
	# endif
	# define SA_ONSTACK 0
	# endif
	# else
	# define SA_ONSTACK 0
	# define RTLD_LOCAL 0
	# endif

	int signal;
	pid_t origine_signal;
	logical1 signal_a_traiter;

/* Contextes */	/* Contextes */

Line 1405 typedef struct processus	Line 1870 typedef struct processus

/* Variables */	/* Variables */

struct_variable *s_liste_variables;	// La liste des variables par niveau est doublement chaînée.
unsigned long nombre_variables;	// À tout moment, elle pointe sur le niveau le plus haut existant et
unsigned long nombre_variables_allouees;	// l_liste_variable_par_niveau->precedent renvoie la liste des
	// définitions. l_liste_variable_par_niveau->precedent->precedent pointe
	// sur la liste des variables globales.
	//
	// À l'initialisation :
	// l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
	// l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau

	struct_arbre_variables *s_arbre_variables;
	struct_liste_variables *l_liste_variables_par_niveau;
	logical1 niveau_supprime;

	struct_variable *pointeur_variable_courante;
	struct_liste_variables *pointeur_feuille_courante;

	int *pointeurs_caracteres_variables;
	int nombre_caracteres_variables;

struct_variable_statique *s_liste_variables_statiques;	struct_variable_statique *s_liste_variables_statiques;
unsigned long nombre_variables_statiques;	unsigned long nombre_variables_statiques;
Line 1418 typedef struct processus	Line 1899 typedef struct processus

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

logical1 creation_variables_statiques;	logical1 creation_variables_statiques;
Line 1597 typedef struct processus	Line 2077 typedef struct processus

/* Traitement des erreurs */	/* Traitement des erreurs */

	unsigned int compteur_violation_d_acces;
unsigned int erreur_compilation;	unsigned int erreur_compilation;
unsigned int erreur_execution;	unsigned int erreur_execution;
unsigned int erreur_systeme;	unsigned int erreur_systeme;
Line 1654 typedef struct processus	Line 2135 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 */

Line 1665 typedef struct processus	Line 2150 typedef struct processus
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 */

	char *rpl_home;

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 1710 typedef struct processus	Line 2202 typedef struct processus

// Mutex spécifique au processus et donnant accès à la pile des processus	// Mutex spécifique au processus et donnant accès à la pile des processus
pthread_mutex_t mutex;	pthread_mutex_t mutex;
	pthread_mutex_t mutex_allocation;

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

/* Mutexes */	/* Mutexes */

Line 1732 typedef struct processus	Line 2229 typedef struct processus
unsigned long taille_pile_objets;	unsigned long taille_pile_objets;
struct_objet *pile_objets;	struct_objet *pile_objets;

# define TAILLE_CACHE 1024	# define TAILLE_CACHE 16384

unsigned long *objets_adr[TAILLE_CACHE];	unsigned long *objets_adr[TAILLE_CACHE];
int pointeur_adr;	int pointeur_adr;
Line 1766 typedef struct processus	Line 2263 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 intrinseque
--------------------------------------------------------------------------------
*/

#ifndef RPLARGS	struct_liste_variables *variables_feuille[TAILLE_CACHE];
typedef struct instruction	int pointeur_variables_feuille;
{
struct instruction **noeud;	struct_variable *variables_variable[TAILLE_CACHE];
void (feuille)(struct_processus );	int pointeur_variables_variable;
} struct_instruction;
#endif

	struct_arbre_variables **variables_tableau_noeuds[TAILLE_CACHE];
	int pointeur_variables_tableau_noeuds;
	} struct_processus;
	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 1819 typedef struct fonction	Line 2313 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 1836 void instruction_asl(struct_processus *s	Line 2331 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 1855 void instruction_clear(struct_processus	Line 2353 void instruction_clear(struct_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 2005 void instruction_ifft(struct_processus *	Line 2505 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 2032 void instruction_lcd_fleche(struct_proce	Line 2534 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 2045 void instruction_lq(struct_processus *s_	Line 2548 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 2053 void instruction_maxs(struct_processus *	Line 2557 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 2107 void instruction_print(struct_processus	Line 2613 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 2220 void instruction_sqlquery(struct_process	Line 2727 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 2277 void instruction_trn(struct_processus *s	Line 2785 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_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 2335 void affichage_pile(struct_processus *s_	Line 2843 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
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);
Line 2353 void conversion_element_tex(unsigned cha	Line 2860 void conversion_element_tex(unsigned cha
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, 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 2365 void deverrouillage_threads_concurrents(	Line 2876 void deverrouillage_threads_concurrents(
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, unsigned long 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, unsigned long duree);
void evaluation_romberg(struct_processus *s_etat_processus,	void evaluation_romberg(struct_processus *s_etat_processus,
Line 2392 void impression_tex(struct_processus *s_	Line 2904 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 2408 void insertion_thread_surveillance(struc	Line 2922 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(SIGHANDLER_ARGS);
void interruption4(int signal, siginfo_t siginfo, void context);	void interruption2(SIGHANDLER_ARGS);
void interruption5(int signal, siginfo_t siginfo, void context);	void interruption3(SIGHANDLER_ARGS);
void interruption6(int signal, siginfo_t siginfo, void context);	void interruption4(SIGHANDLER_ARGS);
void interruption7(int signal, siginfo_t siginfo, void context);	void interruption5(SIGHANDLER_ARGS);
void interruption8(int signal, siginfo_t siginfo, void context);	void interruption6(SIGHANDLER_ARGS);
void interruption9(int signal, siginfo_t siginfo, void context);	void interruption7(SIGHANDLER_ARGS);
void interruption10(int signal, siginfo_t siginfo, void context);	void interruption8(SIGHANDLER_ARGS);
	void interruption9(SIGHANDLER_ARGS);
	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 2432 void liberation_maillon(struct_processus	Line 2949 void liberation_maillon(struct_processus
void liberation_allocateur(struct_processus *s_etat_processus);	void liberation_allocateur(struct_processus *s_etat_processus);
void liberation_arbre_instructions(struct_processus *s_etat_processus,	void liberation_arbre_instructions(struct_processus *s_etat_processus,
struct_instruction *arbre);	struct_instruction *arbre);
	void liberation_arbre_variables(struct_processus *s_etat_processus,
	struct_arbre_variables *arbre, logical1 definitions);
	void liberation_contexte_cas(struct_processus *s_etat_processus);
void liberation_generateur_aleatoire(struct_processus *s_etat_processus);	void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
void liberation_threads(struct_processus *s_etat_processus);	void liberation_threads(struct_processus *s_etat_processus);
void liberation_profil(struct_processus *s_etat_processus);	void liberation_profil(struct_processus *s_etat_processus);
Line 2448 void retrait_thread(struct_processus *s_	Line 2968 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);	void scrutation_injection(struct_processus *s_etat_processus);
	void scrutation_interruptions(struct_processus *s_etat_processus);
void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);	void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
void surveillance_processus(void argument);	void surveillance_processus(void argument);
void swap(void variable_1, void variable_2, unsigned long taille_octets);	void swap(void variable_1, void variable_2, unsigned long taille_octets);
	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);
Line 2475 void valeurs_singulieres(struct_processu	Line 2997 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

	#ifndef RPLARGS
	#ifdef _BROKEN_SIGINFO
	void creation_fifos_signaux(struct_processus *s_etat_processus);
	void destruction_fifos_signaux(struct_processus *s_etat_processus);
	void liberation_fifos_signaux(struct_processus *s_etat_processus);
	#endif
	#endif

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Fonctions de sommation de vecteur dans perte de précision	Fonctions de sommation de vecteur dans perte de précision
Line 2493 complex16 sommation_vecteur_complexe(com	Line 3023 complex16 sommation_vecteur_complexe(com
*/	*/

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

/*	/*
Line 2565 unsigned char *formateur_fichier(struct_	Line 3095 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);
Line 2596 logical1 analyse_syntaxique(struct_proce	Line 3128 logical1 analyse_syntaxique(struct_proce
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,
	unsigned char type, unsigned char somme_candidate);
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 2615 logical1 empilement_pile_last(struct_pro	Line 3149 logical1 empilement_pile_last(struct_pro
unsigned long nombre_arguments);	unsigned long 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 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);
Line 2643 logical1 ecriture_pipe(struct_processus	Line 3181 logical1 ecriture_pipe(struct_processus
struct_objet *s_objet);	struct_objet *s_objet);
logical1 recherche_variable(struct_processus *s_etat_processus,	logical1 recherche_variable(struct_processus *s_etat_processus,
unsigned char *nom_variable);	unsigned char *nom_variable);
	logical1 recherche_variable_globale(struct_processus *s_etat_processus,
	unsigned char *nom_variable);
logical1 recherche_variable_partagee(struct_processus *s_etat_processus,	logical1 recherche_variable_partagee(struct_processus *s_etat_processus,
unsigned char *nom_variable, union_position_variable position,	unsigned char *nom_variable, union_position_variable position,
unsigned char origine);	unsigned char origine);
Line 2662 logical1 test_fonction(unsigned char *ch	Line 3202 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 2675 inline ssize_t write_atomic(struct_proce	Line 3215 inline ssize_t write_atomic(struct_proce
*/	*/

int alsprintf(unsigned char *strp, const char fmt, ...);	int alsprintf(unsigned char *strp, const char fmt, ...);
	int liste_variables(struct_processus *s_etat_processus,
	struct_tableau_variables *tableau, int position,
	struct_arbre_variables *l_element_courant);
	int nombre_variables(struct_processus *s_etat_processus,
	struct_arbre_variables *l_element_courant);
	int tex_fprintf(struct_processus *s_etat_processus,
	file flux, const char format, ...);
int transliterated_fprintf(struct_processus s_etat_processus, file flux,	int transliterated_fprintf(struct_processus s_etat_processus, file flux,
const char *format, ...);	const char *format, ...);
int valsprintf(unsigned char *strp, const char fmt, va_list ap);	int valsprintf(unsigned char *strp, const char fmt, va_list ap);
Line 2735 struct_processus *copie_etat_processus(s	Line 3282 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 2755 struct_objet *copie_objet(struct_process	Line 3302 struct_objet *copie_objet(struct_process
struct_objet *s_objet, unsigned char type);	struct_objet *s_objet, unsigned char type);

#ifndef RPLARGS	#ifndef RPLARGS
	struct_objet allocation(struct_processus s_etat_processus, enum t_type type);
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_pipe(struct_processus s_etat_processus, int pipe);	struct_objet lecture_pipe(struct_processus s_etat_processus, int pipe);
Line 3052 void zgelsy_(integer4 m, integer4 n, i	Line 3600 void zgelsy_(integer4 m, integer4 n, i
* 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.8
changed lines
	Added in v.1.119