--- rpl/src/rpl.h	2010/05/19 09:22:34	1.36
+++ rpl/src/rpl.h	2010/08/06 15:33:04	1.52
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.15
+  RPL/2 (R) version 4.0.18
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -28,10 +28,27 @@
 #define _REENTRANT
 
 #ifdef Darwin
-#	define SIGPOLL			SIGINFO
-#	define _DARWIN_C_SOURCE
+#	define	_DARWIN_C_SOURCE
 #endif
 
+#ifdef OS2
+#	define _BSD_SOURCE
+#	define _XOPEN_SOURCE	600
+
+#	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
+#	define SEM_FAILED	NULL
+#	undef IPV6
+
+#	include "getaddrinfo-conv.h"
+#else
+#	define IPV6
+#endif
+
+
 /*
 ================================================================================
   INCLUSIONS
@@ -66,8 +83,31 @@
 #	include <dlfcn.h>
 #	include <fcntl.h>
 #	include <pthread.h>
+
+#	ifdef OS2
+#		undef pthread_mutexattr_settype
+#		define pthread_mutexattr_settype(a, b)
+#	endif
+
 #	include <pwd.h>
-#	include <semaphore.h>
+
+#	ifndef OS2
+#		include <semaphore.h>
+#	else
+#		include <sys/sem.h>
+		typedef int sem_t;
+
+		sem_t *sem_open(const char *nom, int oflag, ...);
+		int sem_init(sem_t *sem, int shared, unsigned int value);
+		int sem_close(sem_t *sem);
+		int sem_wait(sem_t *sem);
+		int sem_trywait(sem_t *sem);
+		int sem_post(sem_t *sem);
+		int sem_getvalue(sem_t *sem, int *value);
+		int sem_unlink(const char *nom);
+		int sem_destroy(sem_t *sem);
+#	endif
+
 #	include <setjmp.h>
 #	include <signal.h>
 #	include <termios.h>
@@ -127,6 +167,10 @@
 */
 
 #ifndef RPLARGS
+#	if defined(Darwin)
+#		define SIGPOLL				SIGINFO
+#	endif
+
 //	Arrêt par STOP
 #	define SIGFSTOP					SIGUSR1
 //	Démarrage d'un processus fils
@@ -137,6 +181,7 @@
 #	define SIGABORT					SIGPROF
 //	Arrêt d'un processus fils depuis autre chose que STOP
 #	define SIGFABORT				SIGPOLL
+//	Nombre d'interruptions disponibles
 #	define d_NOMBRE_INTERRUPTIONS	64
 #endif
 
@@ -185,7 +230,7 @@ typedef FILE					file;
 typedef unsigned char			t_8_bits;
 
 #ifndef RPLARGS
-#	include "rpltypes.conv.h"
+#	include "rpltypes-conv.h"
 #else
 #	include "rpltypes.h"
 #endif
@@ -357,7 +402,7 @@ int sem_getvalue2(sem_t *semaphore, 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; })
 // 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
@@ -433,17 +478,20 @@ int sem_getvalue2(sem_t *semaphore, int
 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_reinitialisation();
 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
@@ -483,21 +531,6 @@ void debug_memoire_verification();
 		if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
 #endif
 
-#ifdef DEBUG_MALLOC
-#define malloc(taille) ({ size_t s = taille; void *p; \
-		p = malloc(taille); if (p != NULL) memset(p, 0, s); \
-		/*uprintf("[%d-%llu] Allocating %p (%d bytes) at %s() line #%d\n", \
-		(int) getpid(), (unsigned long long) pthread_self(), p, \
-		(int) s, __FUNCTION__, __LINE__); fflush(stdout); */ p; })
-#endif
-
-#ifdef DEBUG_FREE
-#define free(ptr) ({ void *p = ptr; \
-		/*uprintf("[%d-%llu] Freeing %p (%d bytes) at %s() line #%d\n", \
-		(int) getpid(), (unsigned long long) pthread_self(), p, \
-		(int) sizeof(p), __FUNCTION__, __LINE__); fflush(stdout); */ \
-		if (p != NULL) memset(p, 0, sizeof(p)); free(p); })
-#endif
 
 /*
 ================================================================================
@@ -737,6 +770,7 @@ void debug_memoire_verification();
 #	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)
 #endif
 
 
@@ -1138,6 +1172,7 @@ typedef struct descripteur_thread
 	pthread_t					thread_pere;
 
 	pthread_mutex_t				mutex;
+
 	volatile logical1			thread_actif;
 
 	int							pipe_erreurs[2];
@@ -1218,21 +1253,23 @@ typedef struct liste_pile_systeme
 
 	/*
 	type clôture :
-	C     CASE  : END termine un test SELECT/CASE/THEN/END/DEFAULT/END.
-	D     DO    : END termine une boucle DO/UNTIL/END.
-	I     IF    : END termine un test IF/THEN (ELSE)/END.
-	J     IFERR : END termine un test IFERR/THEN (ELSE)/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.
-	L     LOOP  : boucle utilisé dans le traitement de l'instruction RETURN.
+	C     SELECT  : END termine un test SELECT/DEFAULT/END.
+	D     DO      : END termine une boucle DO/UNTIL/END.
+	I     IF      : END termine un test IF/THEN (ELSE)/END.
+	J     IFERR   : END termine un test IFERR/THEN (ELSE)/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.
+	L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
 	        Elle correspond à une boucle FOR ou START mais sans son
 			initialisation.
 	*/
 
 	unsigned long				adresse_retour;
 	unsigned long				niveau_courant;
+	struct_objet				*pointeur_adresse_retour;
 } struct_liste_pile_systeme;
 #endif
 
@@ -1533,7 +1570,7 @@ typedef struct processus
 	pthread_t					thread_fusible;
 	pthread_t					thread_surveille_par_fusible;
 
-#	ifndef Cygwin
+#	if !defined(Cygwin)
 	stack_t						pile_signal;
 #	else
 #	define SA_ONSTACK			0
@@ -1796,8 +1833,10 @@ typedef struct processus
 
 	unsigned char				traitement_interruption;  /* 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									*/
 
@@ -1858,6 +1897,7 @@ typedef struct processus
 
 	// Mutex spécifique au processus et donnant accès à la pile des processus
 	pthread_mutex_t				mutex;
+	pthread_mutex_t				mutex_allocation;
 
 	// Sémaphore autorisant les fork()
 	sem_t
@@ -1993,11 +2033,13 @@ void instruction_asr(struct_processus *s
 void instruction_atan(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_axes(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_backtrace(struct_processus *s_etat_processus);
 void instruction_beep(struct_processus *s_etat_processus);
 void instruction_bessel(struct_processus *s_etat_processus);
 void instruction_bin(struct_processus *s_etat_processus);
@@ -2013,6 +2055,7 @@ void instruction_cllcd(struct_processus
 void instruction_clmf(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_clrerr(struct_processus *s_etat_processus);
 void instruction_clrfuse(struct_processus *s_etat_processus);
@@ -2618,6 +2661,7 @@ void scrutation_injection(struct_process
 void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void *surveillance_processus(void *argument);
 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_exceptions_gsl(const char *reason, const char *file,
 		int line, int gsl_errno);