--- rpl/src/semaphores.c	2010/04/17 18:57:36	1.1
+++ rpl/src/semaphores.c	2020/01/10 11:15:51	1.89
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.14
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,8 +20,42 @@
 */
 
 
-#ifdef SEMAPHORES_NOMMES
-#include "rpl.conv.h"
+#include "rpl-conv.h"
+
+
+// Les fonctions suivantes ne sont utilisées que dans le cas d'un
+// système POSIX qui ne possède pas de sémaphores anonymes. MacOS X
+// est dans ce cas.
+
+static unsigned char *
+nom_segment_semaphore(pid_t pid, int ordre)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = sys_malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-%llu-%d", (unsigned long long) pid, ordre);
+	return(fichier);
+}
+
+
+static unsigned char *
+nom_segment_semaphore_thread(pid_t pid, pthread_t tid, int ordre)
+{
+	unsigned char				*fichier;
+
+	if ((fichier = sys_malloc((1 + 256 + 1) * sizeof(unsigned char))) == NULL)
+	{
+		return(NULL);
+	}
+
+	sprintf(fichier, "/RPL-%llu-%llu-%d", (unsigned long long) pid,
+			(unsigned long long) tid, ordre);
+	return(fichier);
+}
 
 
 /*
@@ -37,72 +71,1113 @@
 */
 
 sem_t *
-sem_init2(unsigned int valeur, enum t_semaphore semaphore)
+sem_init2(unsigned int valeur, pid_t pid, int ordre)
 {
-	snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
-			"/RPLSEM-%d-%llu-%d", (int) getpid(),
-			(unsigned long long) pthread_self(),
-			(int) semaphore);
-	return(sem_open(noms_semaphores[semaphore], O_CREAT,
-			(S_IRUSR | S_IWUSR), valeur));
+	sem_t						*semaphore;
+
+	unsigned char				*chemin;
+	unsigned char				*langue;
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	if ((semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL,
+			S_IRUSR | S_IWUSR, valeur)) == SEM_FAILED)
+	{
+		if (errno == EEXIST)
+		{
+			if ((langue = getenv("LANG")) != NULL)
+			{
+				if (strncmp(langue, "fr", 2) == 0)
+				{
+					uprintf("+++Attention : Le sémaphore %s préexiste !\n",
+							chemin);
+				}
+				else
+				{
+					uprintf("+++Warning: %s semaphore preexists!\n", chemin);
+				}
+			}
+			else
+			{
+				uprintf("+++Warning: %s semaphore preexists!\n", chemin);
+			}
+
+			if (sem_unlink(chemin) != 0)
+			{
+				sys_free(chemin);
+				return(SEM_FAILED);
+			}
+
+			semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL,
+					S_IRUSR | S_IWUSR, valeur);
+		}
+	}
+
+	sys_free(chemin);
+
+	return(semaphore);
+}
+
+
+sem_t *
+sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre)
+{
+	sem_t						*semaphore;
+
+	unsigned char				*chemin;
+	unsigned char				*langue;
+
+	if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	if ((semaphore = sem_open(chemin, O_RDWR | O_CREAT | O_EXCL,
+			S_IRUSR | S_IWUSR, valeur)) == SEM_FAILED)
+	{
+		if (errno == EEXIST)
+		{
+			if ((langue = getenv("LANG")) != NULL)
+			{
+				if (strncmp(langue, "fr", 2) == 0)
+				{
+					uprintf("+++Attention : Le sémaphore %s préexiste !\n",
+							chemin);
+				}
+				else
+				{
+					uprintf("+++Warning: %s semaphore preexists!\n", chemin);
+				}
+			}
+			else
+			{
+				uprintf("+++Warning: %s semaphore preexists!\n", chemin);
+			}
+
+			semaphore = sem_open(chemin, O_RDWR | O_CREAT,
+					S_IRUSR | S_IWUSR, valeur);
+		}
+	}
+
+	sys_free(chemin);
+
+	return(semaphore);
 }
 
+
+sem_t *
+sem_open2(pid_t pid, int ordre)
+{
+	unsigned char				*chemin;
+
+	sem_t						*semaphore;
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+	semaphore = sem_open(chemin, O_RDWR);
+	sys_free(chemin);
+
+	return(semaphore);
+}
+
+
 int
-sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore)
+sem_destroy2(sem_t *semaphore, pid_t pid, int ordre)
 {
-	sem_close(semaphore_p);
-	return(sem_unlink(noms_semaphores[semaphore]));
+	int							erreur;
+
+	unsigned char				*chemin;
+
+	sem_close(semaphore);
+
+	if ((chemin = nom_segment_semaphore(pid, ordre)) == NULL)
+	{
+		return(1);
+	}
+
+	erreur = sem_unlink(chemin);
+	sys_free(chemin);
+
+	return(erreur);
+}
+
+
+int
+sem_destroy3(sem_t *semaphore, pid_t pid, pthread_t tid, int ordre)
+{
+	int							erreur;
+
+	unsigned char				*chemin;
+
+	sem_close(semaphore);
+
+	if ((chemin = nom_segment_semaphore_thread(pid, tid, ordre)) == NULL)
+	{
+		return(1);
+	}
+
+	erreur = sem_unlink(chemin);
+	sys_free(chemin);
+
+	return(erreur);
 }
 
-#undef sem_post
-#undef sem_wait
-#undef sem_trywait
 
 int
 sem_getvalue2(sem_t *semaphore, int *valeur)
 {
 	int						i;
+	int						j;
 
 	logical1				drapeau_fin;
 
-	pthread_mutex_lock(&mutex_sem);
+	struct timespec			attente;
 
-	(*valeur) = 0;
-	drapeau_fin = d_faux;
+	attente.tv_sec = 0;
+	attente.tv_nsec = GRANULARITE_us * 1000;
 
-	do
+	for(j = 0; j < 100; j++)
 	{
-		if (sem_trywait(semaphore) == -1)
+		if (pthread_mutex_trylock(&mutex_sem) == 0)
 		{
-			if (errno == EAGAIN)
+			(*valeur) = 0;
+			drapeau_fin = d_faux;
+
+			do
 			{
-				// Le sémaphore avait une valeur nulle
-				drapeau_fin = d_vrai;
+				if (sem_trywait(semaphore) == -1)
+				{
+					if (errno == EAGAIN)
+					{
+						// Le sémaphore avait une valeur nulle
+						drapeau_fin = d_vrai;
+					}
+					else
+					{
+						// Autre erreur
+						pthread_mutex_unlock(&mutex_sem);
+						return(-1);
+					}
+				}
+				else
+				{
+					(*valeur)++;
+				}
+			} while(drapeau_fin == d_faux);
+
+			for(i = 0; i < (*valeur); i++)
+			{
+				if (sem_post(semaphore) != 0)
+				{
+					pthread_mutex_unlock(&mutex_sem);
+					return(-1);
+				}
 			}
-			else
+
+			pthread_mutex_unlock(&mutex_sem);
+			return(0);
+		}
+
+		nanosleep(&attente, NULL);
+		INCR_GRANULARITE(attente.tv_nsec);
+	}
+
+	// Le mutex n'a pas pu être verrouillé. On peut raisonnablement penser
+	// que le sémaphore est bloqué dans un sem_wait() protégé par ce mutex.
+
+	(*valeur) = 0;
+	return(0);
+}
+
+
+#undef sem_post
+#undef sem_wait
+#undef sem_trywait
+
+
+#ifdef IPCS_SYSV
+
+/*
+================================================================================
+  Fonctions d'émulation de sémaphores POSIX en fonction des sémaphores SysV
+================================================================================
+  Entrées :
+--------------------------------------------------------------------------------
+  Sorties :
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+#ifndef OS2 // IPCS_SYSV
+	extern unsigned char *racine_segment;
+#else // OS/2
+	unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
+	unsigned char racine_memoire_OS2[] = "\\SHAREMEM\\";
+#endif
+
+int
+sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
+{
+	// Création d'un sémaphore anonyme qui devra être supprimé par
+	// sem_destroy_SysV
+
+#	ifndef OS2 // IPCS_SYSV
+		int				desc;
+		int				ios;
+
+		key_t			clef;
+
+		union semun		argument;
+
+		unsigned char	*langue;
+
+		if (shared == 0)
+		{
+			// Sémaphore privé
+			(*semaphore).sem = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL |
+					S_IRUSR | S_IWUSR);
+			(*semaphore).path = NULL;
+			(*semaphore).pid = getpid();
+			(*semaphore).tid = pthread_self();
+			(*semaphore).alloue = 0;
+		}
+		else
+		{
+			// Sémaphore partagé entre plusieurs processus
+			if (((*semaphore).path = sys_malloc((strlen(racine_segment)
+					+ 2 + 256 + 1) * sizeof(unsigned char))) == NULL)
+			{
+				return(-1);
+			}
+
+			sprintf((*semaphore).path, "%s/RPL-SEMAPHORE-%d-%llX-%llX",
+					racine_segment, (int) getpid(),
+					(long long unsigned) pthread_self(),
+					(long long unsigned) semaphore);
+
+			if ((desc = open((*semaphore).path, O_RDWR | O_CREAT | O_EXCL,
+					S_IRUSR | S_IWUSR)) == -1)
+			{
+				if (errno != EEXIST)
+				{
+					sys_free((*semaphore).path);
+					return(-1);
+				}
+
+				if ((langue = getenv("LANG")) != NULL)
+				{
+					if (strncmp(langue, "fr", 2) == 0)
+					{
+						uprintf("+++Attention : Le sémaphore %s préexiste !\n",
+								(*semaphore).path);
+					}
+					else
+					{
+						uprintf("+++Warning: %s semaphore preexists!\n",
+								(*semaphore).path);
+					}
+				}
+				else
+				{
+					uprintf("+++Warning: %s semaphore preexists!\n",
+							(*semaphore).path);
+				}
+
+				if ((desc = open((*semaphore).path, O_RDWR | O_CREAT,
+						S_IRUSR | S_IWUSR)) == -1)
+				{
+					sys_free((*semaphore).path);
+					return(-1);
+				}
+			}
+
+			(*semaphore).pid = getpid();
+			(*semaphore).tid = pthread_self();
+			clef = ftok((*semaphore).path, 1);
+			close(desc);
+
+			if (clef == -1)
 			{
-				// Autre erreur
-				pthread_mutex_unlock(&mutex_sem);
+				sys_free((*semaphore).path);
 				return(-1);
 			}
+
+			(*semaphore).alloue = 0;
+			(*semaphore).sem = semget(clef, 1, IPC_CREAT | IPC_EXCL |
+					S_IRUSR | S_IWUSR);
+		}
+
+		if ((*semaphore).sem == -1)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		argument.val = (int) valeur;
+		ios = semctl((*semaphore).sem, 0, SETVAL, argument);
+
+		return(ios);
+#	else // OS/2
+		sem_t			*psem;
+
+		psem = semaphore;
+
+		if (((*psem).cnt = sys_malloc(sizeof(ULONG))) == NULL)
+		{
+			sys_free(psem);
+			errno = ENOMEM;
+			return(-1);
+		}
+
+		if (((*psem).nopened = sys_malloc(sizeof(ULONG))) == NULL)
+		{
+			sys_free((*psem).cnt);
+			sys_free(psem);
+			errno = ENOMEM;
+			return(-1);
+		}
+
+		if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
+		{
+			sys_free((*psem).cnt);
+			sys_free((*psem).nopened);
+			sys_free(psem);
+			return(-1);
+		}
+
+		if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0)
+				!= 0)
+		{
+			DosCloseMutexSem((*psem).hmtx);
+			sys_free((*psem).cnt);
+			sys_free((*psem).nopened);
+			sys_free(psem);
+			return(-1);
+		}
+
+		(*(*psem).cnt) = valeur;
+		(*(*psem).nopened) = 1;
+		(*psem).shared = shared;
+		(*psem).allocated = 0;
+
+		return(0);
+#	endif
+}
+
+int
+sem_destroy_SysV(sem_t *semaphore)
+{
+	// Détruit un sémaphore anonmyme
+
+#	ifndef OS2 // IPCS_SYSV
+		if ((*semaphore).path != NULL)
+		{
+			return(EINVAL);
+		}
+
+		if ((*semaphore).pid != getpid())
+		{
+			return(0);
+		}
+
+		if (semctl((*semaphore).sem, 0, IPC_RMID) == -1)
+		{
+			return(EINVAL);
+		}
+
+		return(0);
+#	else // OS/2
+		sem_t		*psem;
+
+		psem = semaphore;
+
+		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+		{
+			return(EINVAL);
+		}
+
+		if (DosCloseMutexSem((*psem).hmtx) != 0)
+		{
+			return(EINVAL);
+		}
+
+		while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
+		{
+			DosPostEventSem((*psem).hev);
+		}
+
+		(*(*psem).nopened)--;
+
+		if ((*psem).shared == 0)
+		{
+			sys_free((*psem).cnt);
+			sys_free((*psem).nopened);
 		}
 		else
 		{
-			(*valeur)++;
+			if ((*(*psem).nopened) == 0)
+			{
+				DosFreeMem((*psem).cnt);
+			}
+		}
+
+		if ((*psem).allocated != 0)
+		{	
+			sys_free(psem);
+		}
+
+		return(0);
+#	endif
+}
+
+int
+sem_wait_SysV(sem_t *semaphore)
+{
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
+
+		// semop() ne renvoie pas EINTR sur un signal !
+
+		commande.sem_num = 0;
+		commande.sem_op = -1;
+		commande.sem_flg = 0;
+
+		if (semop((*semaphore).sem, &commande, 1) == -1)
+		{
+			if (errno != EAGAIN)
+			{
+				errno = EINVAL;
+				return(-1);
+			}
+			else
+			{
+				return(-1);
+			}
+		}
+
+		return(0);
+#	else // OS/2
+		sem_t		*psem;
+
+		ULONG		cnt;
+
+		psem = semaphore;
+
+		if (DosWaitEventSem((*psem).hev, SEM_INDEFINITE_WAIT) != 0)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		if ((*(*psem).cnt) > 0)
+		{
+			(*(*psem).cnt)--;
+		}
+
+		if ((*(*psem).cnt) == 0)
+		{
+			DosResetEventSem((*psem).hev, &cnt);
+		}
+
+		DosReleaseMutexSem((*psem).hmtx);
+		return(0);
+#	endif
+}
+
+int
+sem_trywait_SysV(sem_t *semaphore)
+{
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
+
+		commande.sem_num = 0;
+		commande.sem_op = -1;
+		commande.sem_flg = IPC_NOWAIT;
+
+		if (semop((*semaphore).sem, &commande, 1) == -1)
+		{
+			return(-1);
 		}
-	} while(drapeau_fin == d_faux);
 
-	for(i = 0; i < (*valeur); i++)
+		return(0);
+#	else // OS/2
+		int			ios;
+
+		sem_t		*psem;
+
+		ULONG		cnt;
+
+		psem = semaphore;
+
+		if ((ios = DosWaitEventSem((*psem).hev, SEM_IMMEDIATE_RETURN)) != 0)
+		{
+			errno = (ios == ERROR_TIMEOUT) ? EAGAIN : EINVAL;
+			return(-1);
+		}
+
+		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		if ((*(*psem).cnt) > 0)
+		{
+			(*(*psem).cnt)--;
+		}
+
+		if ((*(*psem).cnt) == 0)
+		{
+			DosResetEventSem((*psem).hev, &cnt);
+		}
+
+		DosReleaseMutexSem((*psem).hmtx);
+		return(0);
+#	endif
+}
+
+#ifndef timespeccmp
+#	define timespeccmp(tsp, usp, cmp) \
+			(((tsp)->tv_sec == (usp)->tv_sec) ? \
+			((tsp)->tv_nsec cmp (usp)->tv_nsec) : \
+			((tsp)->tv_sec cmp (usp)->tv_sec))
+#	define timespecadd(tsp, usp, vsp) \
+			do { \
+				(vsp)->tv_sec = (tsp)->tv_sec + (usp)->tv_sec; \
+				(vsp)->tv_nsec = (tsp)->tv_nsec + (usp)->tv_nsec; \
+				if ((vsp)->tv_nsec >= 1000000000L) { \
+					(vsp)->tv_sec++; \
+					(vsp)->tv_nsec -= 1000000000L; \
+				} \
+			} while(0)
+#	define timespecsub(tsp, usp, vsp) \
+			do { \
+				(vsp)->tv_sec = (tsp)->tv_sec - (usp)->tv_sec; \
+				(vsp)->tv_nsec = (tsp)->tv_nsec - (usp)->tv_nsec; \
+				if ((vsp)->tv_nsec < 0) { \
+					(vsp)->tv_sec--; \
+					(vsp)->tv_nsec += 1000000000L; \
+				} \
+			} while(0)
+#endif
+
+int
+sem_timedwait_SysV(sem_t *sem, struct timespec *ts)
+{
+	struct timespec onems = { 0, 1000000 };
+	struct timespec total = { 0, 0 };
+	struct timespec unslept;
+	struct timespec elapsed;
+	struct timespec tmp;
+
+	while(timespeccmp(ts, &total, >))
 	{
-		if (sem_post(semaphore) != 0)
+		if (sem_trywait_SysV(sem) == 0)
+		{
+			return(0);
+		}
+
+		if (errno != EAGAIN)
 		{
-			pthread_mutex_unlock(&mutex_sem);
 			return(-1);
 		}
+
+		nanosleep(&onems, &unslept);
+
+		timespecsub(&onems, &unslept, &elapsed);
+		timespecadd(&total, &elapsed, &tmp);
+		total.tv_sec = tmp.tv_sec;
+		total.tv_nsec = tmp.tv_nsec;
 	}
 
-	pthread_mutex_unlock(&mutex_sem);
-	return(0);
+	errno = ETIMEDOUT;
+	return(-1);
+}
+
+int
+sem_post_SysV(sem_t *semaphore)
+{
+#	ifndef OS2 // IPCS_SYSV
+		struct sembuf		commande;
+
+		commande.sem_num = 0;
+		commande.sem_op = 1;
+		commande.sem_flg = 0;
+
+		while(semop((*semaphore).sem, &commande, 1) == -1)
+		{
+			if (errno != EINTR)
+			{
+				errno = EINVAL;
+				return(-1);
+			}
+		}
+
+		return(0);
+#	else // OS/2
+		sem_t				*psem;
+
+		psem = semaphore;
+
+		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		(*(*psem).cnt)++;
+		DosPostEventSem((*psem).hev);
+		DosReleaseMutexSem((*psem).hmtx);
+
+		return(0);
+#	endif
+}
+
+int
+sem_getvalue_SysV(sem_t *semaphore, int *valeur)
+{
+#	ifndef OS2 // IPCS_SYSV
+		(*valeur) = semctl((*semaphore).sem, 0, GETVAL);
+
+		if ((*valeur) < 0)
+		{
+			return(EINVAL);
+		}
+
+		return(0);
+#	else
+		sem_t				*psem;
+
+		psem = semaphore;
+
+		if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+		{
+			errno = EINVAL;
+			return(-1);
+		}
+
+		(*valeur) = (*(*psem).cnt);
+		DosReleaseMutexSem((*psem).hmtx);
+
+		return(0);
+#	endif
+}
+
+sem_t
+*sem_open_SysV(const char *nom, int oflag, ...)
+//*sem_open(const char *nom, int oflag)
+//*sem_open(const char *nom, int oflag, mode_t mode, unsigned int value)
+{
+	mode_t				mode;
+
+	sem_t				*semaphore;
+
+#	ifndef OS2
+		int				desc;
+
+		key_t			clef;
+
+		union semun		argument;
+
+		unsigned char	*langue;
+#	endif
+
+	unsigned char		*nom_absolu;
+
+	unsigned int		valeur;
+
+	va_list				liste;
+
+#	ifdef OS2
+		sem_t			*psem;
+
+		PVOID			base;
+
+		unsigned char	*ptr;
+		unsigned char	*nom_segment;
+#	endif
+
+#	ifndef OS2 // IPCS_SYSV
+		if ((nom_absolu = sys_malloc((strlen(racine_segment) + strlen(nom)
+				+ 2) * sizeof(unsigned char))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
+
+		sprintf(nom_absolu, "%s/%s", racine_segment, nom);
+
+		if ((semaphore = sys_malloc(sizeof(sem_t))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
+
+		(*semaphore).alloue = -1;
+		(*semaphore).pid = getpid();
+		(*semaphore).tid = pthread_self();
+#	else
+		if ((nom_segment = sys_malloc((strlen(racine_memoire_OS2) + strlen(nom)
+				+ 1) * sizeof(unsigned char))) == NULL)
+		{
+			return(SEM_FAILED);
+		}	
+
+		sprintf(nom_segment, "%s%s", racine_memoire_OS2, nom);
+		ptr = nom_segment;
+
+		while((*ptr) != d_code_fin_chaine)
+		{
+			if ((*ptr) == '/')
+			{
+				(*ptr) = '\\';
+			}
+
+			ptr++;
+		}
+
+		if ((nom_absolu = sys_malloc((strlen(racine_semaphores_OS2) +
+				strlen(nom) + 2) * sizeof(unsigned char))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
+
+		sprintf(nom_absolu, "%s%s", racine_semaphores_OS2, nom);
+		ptr = nom_absolu;
+
+		while((*ptr) != d_code_fin_chaine)
+		{
+			if ((*ptr) == '/')
+			{
+				(*ptr) = '\\';
+			}
+
+			ptr++;
+		}
+
+		(*(ptr + 1)) = d_code_fin_chaine;
+
+		if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
+		{
+			return(SEM_FAILED);
+		}
+
+		(*psem).allocated = 1;
+#	endif
+
+	if ((oflag & O_CREAT) == 0)
+	{
+		// 2 arguments
+
+#		ifndef OS2 // IPCS_SYSV
+			clef = ftok(nom_absolu, 1);
+
+			if (clef == -1)
+			{
+				return(SEM_FAILED);
+			}
+
+			(*semaphore).sem = semget(clef, 0, 0);
+			(*semaphore).path = nom_absolu;
+			(*semaphore).pid = getpid();
+
+			if ((*semaphore).sem == -1)
+			{	
+				sys_free(semaphore);
+				sys_free(nom_absolu);
+
+				return(SEM_FAILED);
+			}
+#		else // OS/2
+			if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
+			{
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+				return(SEM_FAILED);
+			}
+
+			(*ptr) = 'M';
+
+			if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
+			{
+				sys_free(psem);
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+
+				return(SEM_FAILED);
+			}
+
+			(*ptr) = 'S';
+
+			if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
+			{
+				DosCloseMutexSem((*psem).hmtx);
+
+				sys_free(psem);
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+
+				return(SEM_FAILED);
+			}
+
+			if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ)
+					!= 0)
+			{
+				DosCloseMutexSem((*psem).hmtx);
+
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+				sys_free(psem);
+
+				return(SEM_FAILED);
+			}
+
+			sys_free(nom_segment);
+
+			(*psem).cnt = (ULONG *) base;
+			(*psem).nopened = ((ULONG *) base) + 1;
+			(*psem).shared = 1;
+
+			if (DosRequestMutexSem((*psem).hmtx, SEM_INDEFINITE_WAIT) != 0)
+			{
+				DosCloseMutexSem((*psem).hmtx);
+
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+				sys_free(psem);
+
+				return(SEM_FAILED);
+			}
+
+			(*((*psem).nopened))++;
+
+			DosReleaseMutexSem((*psem).hmtx);
+
+			semaphore = psem;
+#		endif
+	}
+	else
+	{
+		// 4 arguments
+
+		// O_CREAT O_EXCL
+		// S_IRUSR S_IWUSR
+
+		va_start(liste, oflag);
+		mode = va_arg(liste, mode_t);
+		valeur = va_arg(liste, unsigned int);
+		va_end(liste);
+
+#		ifndef OS2 // IPCS_SYSV
+			if ((desc = open(nom_absolu, O_CREAT | O_EXCL | O_RDWR,
+					S_IRUSR | S_IWUSR)) == -1)
+			{
+				if (errno != EEXIST)
+				{
+					sys_free(semaphore);
+					sys_free(nom_absolu);
+					return(SEM_FAILED);
+				}
+
+				if ((langue = getenv("LANG")) != NULL)
+				{
+					if (strncmp(langue, "fr", 2) == 0)
+					{
+						uprintf("+++Attention : Le sémaphore %s préexiste !\n",
+								nom_absolu);
+					}
+					else
+					{
+						uprintf("+++Warning: %s semaphore preexists!\n",
+								nom_absolu);
+					}
+				}
+				else
+				{
+					uprintf("+++Warning: %s semaphore preexists!\n",
+							nom_absolu);
+				}
+
+				if ((desc = open(nom_absolu, O_CREAT | O_RDWR,
+						S_IRUSR | S_IWUSR)) == -1)
+				{
+					sys_free(semaphore);
+					sys_free(nom_absolu);
+					return(SEM_FAILED);
+				}
+			}
+
+			if ((clef = ftok(nom_absolu, 1)) == -1)
+			{
+				close(desc);
+				sys_free(semaphore);
+				sys_free(nom_absolu);
+
+				return(SEM_FAILED);
+			}
+
+			close(desc);
+
+			(*semaphore).sem = semget(clef, 1,
+					(((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT) |
+					(((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL) |
+					(int) mode);
+			(*semaphore).path = nom_absolu;
+			(*semaphore).pid = getpid();
+
+			if ((*semaphore).sem == -1)
+			{	
+				sys_free(semaphore);
+				sys_free(nom_absolu);
+
+				return(SEM_FAILED);
+			}
+
+			argument.val = (int) valeur;
+			semctl((*semaphore).sem, 0, SETVAL, argument);
+#		else // OS/2
+			if ((psem = sys_malloc(sizeof(sem_t))) == NULL)
+			{
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+
+				return(SEM_FAILED);
+			}
+
+			(*ptr) = 'M';
+
+			if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
+			{
+				sys_free(psem);
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+
+				return(SEM_FAILED);
+			}
+
+			(*ptr) = 'S';
+
+			if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
+					(valeur != 0) ? 1 : 0) != 0)
+			{
+				DosCloseMutexSem((*psem).hmtx);
+
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+				sys_free(psem);
+
+				return(SEM_FAILED);
+			}
+
+			if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
+					PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
+			{
+				DosCloseMutexSem((*psem).hmtx);
+
+				sys_free(nom_absolu);
+				sys_free(nom_segment);
+				sys_free(psem);
+
+				return(SEM_FAILED);
+			}
+
+			sys_free(nom_segment);
+
+			(*psem).cnt = (ULONG *) base;
+			(*psem).nopened = ((ULONG *) base) + 1;
+			(*(*psem).cnt) = valeur;
+			(*(*psem).nopened) = 1;
+			(*psem).shared = 1;
+			semaphore = psem;
+#		endif
+	}
+
+	return(semaphore);
+}
+
+int
+sem_close_SysV(sem_t *semaphore)
+{
+	// Ferme un sémaphore nommé créé par sem_open_SysV()
+#	ifndef OS2 // IPCS_SYSV
+		if ((*semaphore).path != NULL)
+		{
+			sys_free((*semaphore).path);
+		}
+
+		if ((*semaphore).alloue == -1)
+		{
+			sys_free(semaphore);
+		}
+
+		return(0);
+#	else
+		sem_t		*psem;
+
+		psem = semaphore;
+
+		if (DosCloseMutexSem((*psem).hmtx) != 0)
+		{
+			return(EINVAL);
+		}
+
+		while(DosCloseEventSem((*psem).hev) == ERROR_SEM_BUSY)
+		{
+			DosPostEventSem((*psem).hev);
+		}
+
+		(*(*psem).nopened)--;
+
+		if ((*psem).shared == 0)
+		{
+			sys_free((*psem).cnt);
+			sys_free((*psem).nopened);
+		}
+		else
+		{
+			if ((*(*psem).nopened) == 0)
+			{
+				DosFreeMem((*psem).cnt);
+			}
+		}
+
+		if ((*psem).allocated != 0)
+		{
+			sys_free(psem);
+		}
+
+		return(0);
+#	endif
+}
+
+int
+sem_unlink_SysV(char *nom)
+{
+	// Détruit un sémaphore nommé créé par sem_open_SysV()
+#	ifndef OS2 // IPCS_SYSV
+		semctl(semget(ftok(nom, 1), 0, 0), 0, IPC_RMID);
+
+		if (unlink(nom) == -1)
+		{
+			return(EACCES);
+		}
+
+		sys_free(nom);
+		return(0);
+#	else
+		return(0);
+#	endif
 }
 
 #endif