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.60 and 1.127

version 1.60, 2010/08/22 16:38:36	version 1.127, 2011/09/20 07:16:40
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.18	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 23	Line 23
#ifndef INCLUSION_RPL	#ifndef INCLUSION_RPL
#define INCLUSION_RPL	#define INCLUSION_RPL

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

#define _REENTRANT	#define _REENTRANT

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

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

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

# include <types.h>	# include <types.h>
enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };	enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
Line 92	Line 99
# endif	# endif

# include <pwd.h>	# include <pwd.h>
	# include <sys/shm.h>

# ifdef _BROKEN_SIGINFO	# ifndef __RPLCAS
# include <sys/ipc.h>	# ifndef IPCS_SYSV
# include <sys/shm.h>	# include <semaphore.h>
# endif

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

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

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

sem_t sem_open_SysV(const char nom, int oflag, ...);	# ifndef SEM_FAILED
int sem_init_SysV(sem_t *sem, int shared, unsigned int value);	# define SEM_FAILED NULL
int sem_close_SysV(sem_t *sem);	# endif
int sem_wait_SysV(sem_t *sem);
int sem_trywait_SysV(sem_t *sem);	sem_t sem_open_SysV(const char nom, int oflag, ...);
int sem_post_SysV(sem_t *sem);	int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
int sem_getvalue_SysV(sem_t sem, int value);	int sem_close_SysV(sem_t *sem);
int sem_unlink_SysV(const char *nom);	int sem_wait_SysV(sem_t *sem);
int sem_destroy_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
# endif	# endif

# include <setjmp.h>	# include <setjmp.h>
Line 193	Line 201

#include "librplprototypes.h"	#include "librplprototypes.h"

#ifndef UNIX_PATH_MAX	#ifndef RPLARGS
struct sockaddr_un sizecheck;	# ifndef UNIX_PATH_MAX
# define UNIX_PATH_MAX sizeof(sizecheck.sun_path)	struct sockaddr_un sizecheck;
	# define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
	# endif
#endif	#endif

/*	/*
Line 204	Line 214
================================================================================	================================================================================
*/	*/

#ifdef _BROKEN_SIGINFO	enum signaux_rpl
# define SIGHANDLER_ARGS int signal	{
# ifdef SA_SIGINFO	rpl_signull = 0,
# undef SA_SIGINFO	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.

	typedef struct queue_signaux
	{
	# ifndef IPCS_SYSV
	# ifndef SEMAPHORES_NOMMES
	sem_t semaphore;
	# endif
	# else
	sem_t semaphore;
# endif	# endif
# define SA_SIGINFO 0

# define kill(pid, signal) kill_broken_siginfo(pid, signal)	volatile int pointeur_lecture;
# define pthread_kill(tid, signal) pthread_kill_broken_siginfo(tid, signal)	volatile int pointeur_ecriture;
int kill_broken_siginfo(pid_t pid, int signal);
int pthread_kill_broken_siginfo(pthread_t tid, int signal);	volatile struct
#else	{
# define SIGHANDLER_ARGS int signal, siginfo_t siginfo, void context	pid_t pid;
	enum signaux_rpl signal;
	} queue[LONGUEUR_QUEUE_SIGNAUX];
	} struct_queue_signaux;

	#ifndef RPLARGS
	# ifndef MAIN_RPL
	extern struct_queue_signaux *s_queue_signaux;
	extern int f_queue_signaux;
	# ifdef SEMAPHORES_NOMMES
	extern sem_t *semaphore_queue_signaux;
	# endif
	# else
	struct_queue_signaux *s_queue_signaux;
	int f_queue_signaux;
	# ifdef SEMAPHORES_NOMMES
	sem_t *semaphore_queue_signaux;
	# endif
	# endif
#endif	#endif

#ifdef OpenBSD	#ifdef OpenBSD
Line 226	Line 285
# define PTHREAD_SCOPE_SYSTEM 0	# define PTHREAD_SCOPE_SYSTEM 0
#endif	#endif

#if ! defined(UNION_SEMUN) && defined(SEMAPHORES_SYSV)	#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	union semun
{	{
int val;	int val;
Line 243 union semun	Line 307 union semun
================================================================================	================================================================================
*/	*/

#ifdef SEMAPHORES_SYSV	#ifdef IPCS_SYSV
# define sem_init(a, b, c) sem_init_SysV(a, b, c)	# define sem_init(a, b, c) sem_init_SysV(a, b, c)
# define sem_destroy(a) sem_destroy_SysV(a)	# define sem_destroy(a) sem_destroy_SysV(a)
# define sem_wait(a) sem_wait_SysV(a)	# define sem_wait(a) sem_wait_SysV(a)
Line 272 union semun	Line 336 union semun
// SIGPIPE	// SIGPIPE
// SIGALRM	// SIGALRM

// Arrêt par STOP	# define SIGTEST SIGUSR1
# 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 358 typedef unsigned char t_8_bits;	Line 404 typedef unsigned char t_8_bits;
# endif	# endif

# ifndef MAIN_RPL	# ifndef MAIN_RPL
# ifdef _BROKEN_SIGINFO
extern int *fifos_signaux;
# endif

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

# ifdef SEMAPHORES_NOMMES	extern int signal_test;
extern pthread_mutex_t mutex_sem;
# endif

extern pthread_key_t semaphore_fork_processus_courant;	extern pid_t pid_processus_pere;

extern sem_t
# ifdef SEMAPHORES_NOMMES	# ifdef SEMAPHORES_NOMMES
*	extern pthread_mutex_t mutex_sem;
# endif	# endif
semaphore_liste_threads;

extern sem_t	extern pthread_mutex_t mutex_liste_threads;
# ifdef SEMAPHORES_NOMMES	extern pthread_mutex_t mutex_gestionnaires_signaux_atomique;
*
# endif
semaphore_gestionnaires_signaux;

extern sem_t	extern sem_t
# ifdef SEMAPHORES_NOMMES	# 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	# endif
	semaphore_gestionnaires_signaux;
# else	# else
# ifdef _BROKEN_SIGINFO
int *fifos_signaux;
# endif

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

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

pthread_key_t semaphore_fork_processus_courant;	pid_t pid_processus_pere;

sem_t
# ifdef SEMAPHORES_NOMMES	# ifdef SEMAPHORES_NOMMES
*	pthread_mutex_t mutex_sem = PTHREAD_MUTEX_INITIALIZER;
# endif	# endif
semaphore_liste_threads;

	pthread_mutex_t mutex_liste_threads =
	PTHREAD_MUTEX_INITIALIZER;
	pthread_mutex_t mutex_gestionnaires_signaux =
	PTHREAD_MUTEX_INITIALIZER;
	pthread_mutex_t mutex_gestionnaires_signaux_atomique =
	PTHREAD_MUTEX_INITIALIZER;
sem_t	sem_t
# ifdef SEMAPHORES_NOMMES	# ifdef SEMAPHORES_NOMMES
*	*
# endif	# endif
semaphore_gestionnaires_signaux;	semaphore_gestionnaires_signaux;

sem_t
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_gestionnaires_signaux_atomique;

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

#ifdef SEMAPHORES_NOMMES	#ifdef SEMAPHORES_NOMMES
enum t_semaphore { sem_liste_threads = 0,	sem_t *sem_init2(unsigned int valeur, pid_t pid);
sem_gestionnaires_signaux = 1,	int sem_destroy2(sem_t *semaphore_p, pid_t pid);
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);	int sem_getvalue2(sem_t semaphore, int valeur);
	sem_t *sem_open2(pid_t pid);

	// 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 476 int sem_getvalue2(sem_t *semaphore, int	Line 493 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) \
{ 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 724 pid_t debug_fork();	Line 740 pid_t debug_fork();
Erreurs système	Erreurs système
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
	#define DEBUG_ERREURS
#ifdef DEBUG_ERREURS	#ifdef DEBUG_ERREURS
# ifdef MESSAGES	# ifdef MESSAGES
# define __erreur(i) i	# define __erreur(i) i
Line 901 pid_t debug_fork();	Line 917 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)
#endif	#endif


Line 924 pid_t debug_fork();	Line 942 pid_t debug_fork();
# undef MAX	# undef MAX
#endif	#endif

#define ADR __RPL_ADR	#define ADR __RPL_ADR
#define ALG __RPL_ALG	#define ALG __RPL_ALG
#define BIN __RPL_BIN	#define BIN __RPL_BIN
#define CHN __RPL_CHN	#define CHN __RPL_CHN
#define CPL __RPL_CPL	#define CPL __RPL_CPL
Line 944 pid_t debug_fork();	Line 962 pid_t debug_fork();
#define RPN __RPL_RPN	#define RPN __RPL_RPN
#define SCK __RPL_SCK	#define SCK __RPL_SCK
#define SLB __RPL_SLB	#define SLB __RPL_SLB
#define SPH __RPL_SPH	#define SPH __RPL_SPH
#define SQL __RPL_SQL	#define SQL __RPL_SQL
#define TBL __RPL_TBL	#define TBL __RPL_TBL
#define VCX __RPL_VCX	#define VCX __RPL_VCX
#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 1338 typedef struct descripteur_thread	Line 1357 typedef struct descripteur_thread
pthread_t thread_pere;	pthread_t thread_pere;

pthread_mutex_t mutex;	pthread_mutex_t mutex;
	pthread_mutex_t mutex_nombre_references;

volatile logical1 thread_actif;	volatile logical1 thread_actif;

Line 1356 typedef struct descripteur_thread	Line 1376 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 1648 typedef struct rpl_arguments	Line 1665 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 1685 typedef struct processus	Line 1764 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 1693 typedef struct processus	Line 1773 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 1738 typedef struct processus	Line 1818 typedef struct processus

# if !defined(Cygwin)	# if !defined(Cygwin)
# if !(OpenBSD)	# if !(OpenBSD)
stack_t pile_signal;	stack_t pile_signal;
# else	# else
# ifdef SA_ONSTACK	# ifdef SA_ONSTACK
# undef SA_ONSTACK	# undef SA_ONSTACK
Line 1746 typedef struct processus	Line 1826 typedef struct processus
# define SA_ONSTACK 0	# define SA_ONSTACK 0
# endif	# endif
# else	# else
# define SA_ONSTACK 0	# define SA_ONSTACK 0
# define RTLD_LOCAL 0	# define RTLD_LOCAL 0
# endif	# endif

	volatile int pointeur_signal_ecriture;
	volatile int pointeur_signal_lecture;
	volatile enum signaux_rpl signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
	volatile logical1 demarrage_fils;
	volatile logical1 redemarrage_processus;

/* Contextes */	/* Contextes */

struct_liste_chainee *l_base_pile_contextes;	struct_liste_chainee *l_base_pile_contextes;
Line 1757 typedef struct processus	Line 1843 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 1770 typedef struct processus	Line 1872 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 1949 typedef struct processus	Line 2050 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 2021 typedef struct processus	Line 2123 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;

Line 2035 typedef struct processus	Line 2138 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 2072 typedef struct processus	Line 2177 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	pthread_mutex_t mutex_fork;
# ifdef SEMAPHORES_NOMMES
*
# endif
semaphore_fork;

/* Mutexes */	/* Mutexes */

Line 2097 typedef struct processus	Line 2198 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 2135 typedef struct processus	Line 2232 typedef struct processus

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

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

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

	struct_variable *variables_variable[TAILLE_CACHE];
	int pointeur_variables_variable;

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

/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 2188 typedef struct fonction	Line 2282 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 2384 void instruction_in(struct_processus *s_	Line 2479 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 2407 void instruction_lcd_fleche(struct_proce	Line 2503 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 2420 void instruction_lq(struct_processus *s_	Line 2517 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 2598 void instruction_sqlquery(struct_process	Line 2696 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 2655 void instruction_trn(struct_processus *s	Line 2754 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 2713 void affichage_pile(struct_processus *s_	Line 2812 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 2734 void conversion_hms_vers_decimal(real8 *	Line 2832 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 2773 void impression_tex(struct_processus *s_	Line 2873 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 2789 void insertion_thread_surveillance(struc	Line 2891 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 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 2814 void liberation_maillon(struct_processus	Line 2912 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 2831 void retrait_thread_surveillance(struct_	Line 2932 void retrait_thread_surveillance(struct_
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);
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);
Line 2858 void valeurs_singulieres(struct_processu	Line 2960 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 2956 unsigned char *formateur_fichier(struct_	Line 3066 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 3040 logical1 ecriture_pipe(struct_processus	Line 3152 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 3072 ssize_t write_atomic(struct_processus *s	Line 3186 ssize_t write_atomic(struct_processus *s
*/	*/

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,	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 3154 struct_objet *copie_objet(struct_process	Line 3273 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);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.60
changed lines
	Added in v.1.127