--- rpl/src/semaphores.c	2010/08/06 15:26:51	1.6
+++ rpl/src/semaphores.c	2010/08/17 11:59:28	1.10
@@ -40,7 +40,7 @@ sem_t *
 sem_init2(unsigned int valeur, enum t_semaphore semaphore)
 {
 	snprintf(noms_semaphores[semaphore], LONGUEUR_NOM_SEMAPHORE,
-			"/RPLSEM-%d-%llu-%d", (int) getpid(),
+			"/RPL-SEM-%d-%llu-%d", (int) getpid(),
 			(unsigned long long) pthread_self(),
 			(int) semaphore);
 	return(sem_open(noms_semaphores[semaphore], O_CREAT,
@@ -107,7 +107,7 @@ sem_getvalue2(sem_t *semaphore, int *val
 
 #endif
 
-#ifdef OS2
+#ifdef SEMAPHORES_SYSV
 
 /*
 ================================================================================
@@ -121,45 +121,168 @@ sem_getvalue2(sem_t *semaphore, int *val
 ================================================================================
 */
 
-extern unsigned char *chemin_semaphores_SysV;
+#ifndef OS2
+	extern unsigned char *chemin_semaphores_SysV;
+#else
+	unsigned char racine_semaphores_OS2[] = "\\SEM32\\";
+	unsigned char racine_memoire_OS2[] = "\\SHAREDMEM\\";
+#endif
+
+#ifndef UNION_SEMUN
+union semun
+{
+	int					val;
+	struct semid_ds		*buf;
+	unsigned short		*array;
+	struct seminfo		*__buf;
+};
+#endif
 
 int
-sem_init(sem_t *semaphore, int shared, unsigned int valeur)
+sem_init_SysV(sem_t *semaphore, int shared, unsigned int valeur)
 {
+#	ifndef OS2
+
+	int				ios;
+
 	union semun		argument;
 
 	if (shared != 0)
 	{
-		return(ENOSYS);
+		errno = ENOSYS;
+		return(-1);
 	}
 
 	(*semaphore) = semget(IPC_PRIVATE, 1, IPC_CREAT | IPC_EXCL | SEM_R | SEM_A);
 
 	if ((*semaphore) == -1)
 	{
-		return(EINVAL);
+		errno = EINVAL;
+		return(-1);
 	}
 
 	argument.val = valeur;
-	semctl((*semaphore), 0, SETVAL, argument);
+	ios = semctl((*semaphore), 0, SETVAL, argument);
+
+	return(ios);
+
+#	else
+
+	sem_t			*psem;
+
+	psem = semaphore;
+
+	if (shared != 0)
+	{
+		errno = ENOSYS;
+		return(-1);
+	}
+
+	if (((*psem).cnt = malloc(sizeof(ULONG))) == NULL)
+	{
+		free(psem);
+		errno = ENOMEM;
+		return(-1);
+	}
+
+	if (((*psem).nopened = malloc(sizeof(ULONG))) == NULL)
+	{
+		free((*psem).cnt);
+		free(psem);
+		errno = ENOMEM;
+		return(-1);
+	}
+
+	if (DosCreateMutexSem(NULL, &((*psem).hmtx), 0, 0) != 0)
+	{
+		free((*psem).cnt);
+		free((*psem).nopened);
+		free(psem);
+		return(-1);
+	}
+
+	if (DosCreateEventSem(NULL, &((*psem).hev), 0, (valeur != 0) ? 1 : 0) != 0)
+	{
+		DosCloseMutexSem((*psem).hmtx);
+		free((*psem).cnt);
+		free((*psem).nopened);
+		free(psem);
+		return(-1);
+	}
+
+	(*(*psem).cnt) = valeur;
+	(*(*psem).nopened) = 1;
+	(*psem).shared = shared;
+	(*psem).allocated = 0;
 
 	return(0);
+
+#	endif
 }
 
 int
-sem_destroy(sem_t *semaphore)
+sem_destroy_SysV(sem_t *semaphore)
 {
+#	ifndef OS2
+
 	if (semctl((*semaphore), IPC_RMID, 0) == -1)
 	{
 		return(EINVAL);
 	}
 
 	return(0);
+
+#	else
+
+	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)
+	{
+		free((*psem).cnt);
+		free((*psem).nopened);
+	}
+	else
+	{
+		if ((*(*psem).nopened) == 0)
+		{
+			DosFreeMem((*psem).cnt);
+		}
+	}
+
+	if ((*psem).allocated != 0)
+	{	
+		free(psem);
+	}
+
+	return(0);
+
+#	endif
 }
 
 int
-sem_wait(sem_t *semaphore)
+sem_wait_SysV(sem_t *semaphore)
 {
+#	ifndef OS2
+
 	struct sembuf		commande;
 
 	commande.sem_num = 0;
@@ -168,15 +291,53 @@ sem_wait(sem_t *semaphore)
 
 	if (semop((*semaphore), &commande, 1) == -1)
 	{
-		return(EINVAL);
+		errno = EINVAL;
+		return(-1);
+	}
+
+	return(0);
+
+#	else
+
+	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(sem_t *semaphore)
+sem_trywait_SysV(sem_t *semaphore)
 {
+#	ifndef OS2
+
 	struct sembuf		commande;
 
 	commande.sem_num = 0;
@@ -185,20 +346,54 @@ sem_trywait(sem_t *semaphore)
 
 	if (semop((*semaphore), &commande, 1) == -1)
 	{
-		if (errno == EAGAIN)
-		{
-			return(EAGAIN);
-		}
+		return(-1);
+	}
 
-		return(EINVAL);
+	return(0);
+
+#	else
+
+	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
 }
 
 int
-sem_post(sem_t *semaphore)
+sem_post_SysV(sem_t *semaphore)
 {
+#	ifndef OS2
+
 	struct sembuf		commande;
 
 	commande.sem_num = 0;
@@ -207,15 +402,38 @@ sem_post(sem_t *semaphore)
 
 	if (semop((*semaphore), &commande, 1) == -1)
 	{
-		return(EINVAL);
+		errno = EINVAL;
+		return(-1);
 	}
 
 	return(0);
+
+#	else
+
+	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(sem_t *semaphore, int *valeur)
+sem_getvalue_SysV(sem_t *semaphore, int *valeur)
 {
+#	ifndef OS2
+
 	(*valeur) = semctl((*semaphore), 0, GETVAL);
 
 	if ((*valeur) < 0)
@@ -224,10 +442,29 @@ sem_getvalue(sem_t *semaphore, int *vale
 	}
 
 	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(const char *nom, int oflag, ...)
+*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)
 {
@@ -235,7 +472,13 @@ sem_t
 
 	sem_t				*semaphore;
 
+#	ifndef OS2
+	file				*desc;
+
+	key_t				clef;
+
 	union semun			argument;
+#	endif
 
 	unsigned char		*nom_absolu;
 
@@ -243,6 +486,17 @@ sem_t
 
 	va_list				liste;
 
+#	ifdef OS2
+	sem_t				*psem;
+
+	PVOID				base;
+
+	unsigned char		*ptr;
+	unsigned char		*nom_segment;
+#	endif
+
+#	ifndef OS2
+
 	if ((nom_absolu = malloc((strlen(chemin_semaphores_SysV) + strlen(nom)
 			+ 1) * sizeof(unsigned char))) == NULL)
 	{
@@ -256,9 +510,63 @@ sem_t
 		return(SEM_FAILED);
 	}
 
+	(*psem).allocated = 1;
+
+#	else
+
+	if ((nom_segment = 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 = 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 = malloc(sizeof(sem_t))) == NULL)
+	{
+		return(SEM_FAILED);
+	}
+
+#	endif
+
 	if ((oflag & O_CREAT) == 0)
 	{
 		// 2 arguments
+
+#		ifndef OS2
+
 		(*semaphore) = semget(ftok(nom_absolu, 1), 0, 0);
 
 		if ((*semaphore) == -1)
@@ -268,6 +576,75 @@ sem_t
 
 			return(SEM_FAILED);
 		}
+
+#		else
+
+		if ((psem = malloc(sizeof(sem_t))) == NULL)
+		{
+			free(nom_absolu);
+			free(nom_segment);
+			return(SEM_FAILED);
+		}
+
+		(*ptr) = 'M';
+
+		if (DosOpenMutexSem(nom_absolu, &((*psem).hmtx)) != 0)
+		{
+			free(psem);
+			free(nom_absolu);
+			free(nom_segment);
+
+			return(SEM_FAILED);
+		}
+
+		(*ptr) = 'S';
+
+		if (DosOpenEventSem(nom_absolu, &((*psem).hev)) != 0)
+		{
+			DosCloseMutexSem((*psem).hmtx);
+
+			free(psem);
+			free(nom_absolu);
+			free(nom_segment);
+
+			return(SEM_FAILED);
+		}
+
+		if (DosGetNamedSharedMem(&base, nom_segment, PAG_WRITE | PAG_READ) != 0)
+		{
+			DosCloseMutexSem((*psem).hmtx);
+
+			free(nom_absolu);
+			free(nom_segment);
+			free(psem);
+
+			return(SEM_FAILED);
+		}
+
+		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);
+
+			free(nom_absolu);
+			free(nom_segment);
+			free(psem);
+
+			return(SEM_FAILED);
+		}
+
+		(*((*psem).nopened))++;
+
+		DosReleaseMutexSem((*psem).hmtx);
+
+		semaphore = psem;
+
+#		endif
 	}
 	else
 	{
@@ -281,7 +658,27 @@ sem_t
 		valeur = va_arg(liste, unsigned int);
 		va_end(liste);
 
-		(*semaphore) = semget(ftok(nom_absolu, 1), 1,
+#		ifndef OS2
+
+		if ((desc = fopen(nom_absolu, "w")) == NULL)
+		{
+			free(semaphore);
+			free(nom_absolu);
+
+			return(SEM_FAILED);
+		}
+
+		fclose(desc);
+
+		if ((clef = ftok(nom_absolu, 1)) == -1)
+		{
+			free(semaphore);
+			free(nom_absolu);
+
+			return(SEM_FAILED);
+		}
+
+		(*semaphore) = semget(clef, 1,
 				((oflag & O_CREAT) == 0) ? 0 : IPC_CREAT |
 				((oflag & O_EXCL) == 0) ? 0 : IPC_EXCL |
 				((oflag & S_IRUSR) == 0) ? 0 : SEM_R |
@@ -297,23 +694,125 @@ sem_t
 
 		argument.val = valeur;
 		semctl((*semaphore), 0, SETVAL, argument);
+
+#		else
+
+		if ((psem = malloc(sizeof(sem_t))) == NULL)
+		{
+			free(nom_absolu);
+			free(nom_segment);
+
+			return(SEM_FAILED);
+		}
+
+		(*ptr) = 'M';
+
+		if (DosCreateMutexSem(nom_absolu, &((*psem).hmtx), 0, 0) != 0)
+		{
+			free(psem);
+			free(nom_absolu);
+			free(nom_segment);
+
+			return(SEM_FAILED);
+		}
+
+		(*ptr) = 'S';
+
+		if (DosCreateEventSem(nom_absolu, &((*psem).hev), 0,
+				(valeur != 0) ? 1 : 0) != 0)
+		{
+			DosCloseMutexSem((*psem).hmtx);
+
+			free(nom_absolu);
+			free(nom_segment);
+			free(psem);
+
+			return(SEM_FAILED);
+		}
+
+		if (DosAllocSharedMem(&base, nom_segment, 2 * sizeof(ULONG),
+				PAG_WRITE | PAG_READ | PAG_COMMIT) != 0)
+		{
+			DosCloseMutexSem((*psem).hmtx);
+
+			free(nom_absolu);
+			free(nom_segment);
+			free(psem);
+
+			return(SEM_FAILED);
+		}
+
+		free(nom_segment);
+
+		(*psem).cnt = (ULONG *) base;
+		(*psem).nopened = ((ULONG *) base) + 1;
+		(*(*psem).cnt) = valeur;
+		(*(*psem).nopened) = 1;
+		(*psem).shared = 1;
+		semaphore = psem;
+
+#		endif
 	}
 
 	free(nom_absolu);
 
-	return(SEM_FAILED);
+	return(semaphore);
 }
 
 int
-sem_close(sem_t *semaphore)
+sem_close_SysV(sem_t *semaphore)
 {
+#	ifndef OS2
+
 	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)
+	{
+		free((*psem).cnt);
+		free((*psem).nopened);
+	}
+	else
+	{
+		if ((*(*psem).nopened) == 0)
+		{
+			DosFreeMem((*psem).cnt);
+		}
+	}
+
+	if ((*psem).allocated != 0)
+	{
+		free(psem);
+	}
+
+	return(0);
+
+#	endif
 }
 
 int
-sem_unlink(const char *nom)
+sem_unlink_SysV(const char *nom)
 {
+#	ifndef OS2
+
 	sem_t				semaphore;
 
 	struct sembuf		commande;
@@ -359,6 +858,12 @@ sem_unlink(const char *nom)
 	free(nom_absolu);
 
 	return(0);
+
+#	else
+
+	return(0);
+
+#	endif
 }
 
 #endif