Remove the unused & broken PyThread_*_sema() functions and related constants.

freddrake · freddrake · commit 7bb1c9a11db2 · 2002-01-19T22:02:55.000Z
This closes SF patch #504215.
diff --git a/Include/pythread.h b/Include/pythread.h
@@ -25,13 +25,6 @@ DL_IMPORT(int) PyThread_acquire_lock(PyThread_type_lock, int);
 #define NOWAIT_LOCK	0
 DL_IMPORT(void) PyThread_release_lock(PyThread_type_lock);
 
-DL_IMPORT(PyThread_type_sema) PyThread_allocate_sema(int);
-DL_IMPORT(void) PyThread_free_sema(PyThread_type_sema);
-DL_IMPORT(int) PyThread_down_sema(PyThread_type_sema, int);
-#define WAIT_SEMA	1
-#define NOWAIT_SEMA	0
-DL_IMPORT(void) PyThread_up_sema(PyThread_type_sema);
-
 #ifndef NO_EXIT_PROG
 DL_IMPORT(void) PyThread_exit_prog(int);
 DL_IMPORT(void) PyThread__PyThread_exit_prog(int);
diff --git a/Python/thread_beos.h b/Python/thread_beos.h
@@ -285,73 +285,3 @@ void PyThread_release_lock( PyThread_type_lock lock )
 		return;
 	}
 }
-
-/* ----------------------------------------------------------------------
- * Semaphore support.
- *
- * Guido says not to implement this because it's not used anywhere;
- * I'll do it anyway, you never know when it might be handy, and it's
- * easy...
- */
-PyThread_type_sema PyThread_allocate_sema( int value )
-{
-	sem_id sema;
-	
-	dprintf(("PyThread_allocate_sema called\n"));
-
-	sema = create_sem( value, "python semaphore" );
-	if( sema < B_NO_ERROR ) {
-		/* TODO: that's bad, raise an exception */
-		return 0;
-	}
-
-	dprintf(("PyThread_allocate_sema() -> %p\n", sema));
-	return (PyThread_type_sema) sema;
-}
-
-void PyThread_free_sema( PyThread_type_sema sema )
-{
-	status_t retval;
-	
-	dprintf(("PyThread_free_sema(%p) called\n", sema));
-	
-	retval = delete_sem( (sem_id)sema );
-	if( retval != B_NO_ERROR ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
-}
-
-int PyThread_down_sema( PyThread_type_sema sema, int waitflag )
-{
-	status_t retval;
-
-	dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
-
-	if( waitflag ) {
-		retval = acquire_sem( (sem_id)sema );
-	} else {
-		retval = acquire_sem_etc( (sem_id)sema, 1, B_TIMEOUT, 0 );
-	}
-	
-	if( retval != B_NO_ERROR ) {
-		/* TODO: that's bad, raise an exception */
-		return 0;
-	}
-
-	dprintf(("PyThread_down_sema(%p) return\n", sema));
-	return -1;
-}
-
-void PyThread_up_sema( PyThread_type_sema sema )
-{
-	status_t retval;
-	
-	dprintf(("PyThread_up_sema(%p)\n", sema));
-	
-	retval = release_sem( (sem_id)sema );
-	if( retval != B_NO_ERROR ) {
-		/* TODO: that's bad, raise an exception */
-		return;
-	}
-}
diff --git a/Python/thread_cthread.h b/Python/thread_cthread.h
@@ -154,49 +154,3 @@ PyThread_release_lock(PyThread_type_lock lock)
 	dprintf(("PyThread_release_lock(%p) called\n", lock));
 	mutex_unlock((mutex_t )lock);
 }
-
-/*
- * Semaphore support.
- *
- * This implementation is ripped directly from the pthreads implementation.
- * Which is to say that it is 100% non-functional at this time.
- *
- * Assuming the page is still up, documentation can be found at:
- *
- * http://www.doc.ic.ac.uk/~mac/manuals/solaris-manual-pages/solaris/usr/man/man2/_lwp_sema_wait.2.html
- *
- * Looking at the man page, it seems that one could easily implement a
- * semaphore using a condition.
- *
- */
-PyThread_type_sema
-PyThread_allocate_sema(int value)
-{
-	char *sema = 0;
-	dprintf(("PyThread_allocate_sema called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	dprintf(("PyThread_allocate_sema() -> %p\n", sema));
-	return (PyThread_type_sema) sema;
-}
-
-void
-PyThread_free_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_free_sema(%p) called\n", sema));
-}
-
-int
-PyThread_down_sema(PyThread_type_sema sema, int waitflag)
-{
-	dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
-	dprintf(("PyThread_down_sema(%p) return\n", sema));
-	return -1;
-}
-
-void
-PyThread_up_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_up_sema(%p)\n", sema));
-}
diff --git a/Python/thread_foobar.h b/Python/thread_foobar.h
@@ -113,37 +113,3 @@ PyThread_release_lock(PyThread_type_lock lock)
 {
 	dprintf(("PyThread_release_lock(%p) called\n", lock));
 }
-
-/*
- * Semaphore support.
- */
-PyThread_type_sema
-PyThread_allocate_sema(int value)
-{
-	dprintf(("PyThread_allocate_sema called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
-	return (PyThread_type_sema) sema;
-}
-
-void
-PyThread_free_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_free_sema(%p) called\n",  sema));
-}
-
-int
-PyThread_down_sema(PyThread_type_sema sema, int waitflag)
-{
-	dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));
-	dprintf(("PyThread_down_sema(%p) return\n",  sema));
-	return -1;
-}
-
-void
-PyThread_up_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_up_sema(%p)\n",  sema));
-}
diff --git a/Python/thread_lwp.h b/Python/thread_lwp.h
@@ -147,34 +147,3 @@ void PyThread_release_lock(PyThread_type_lock lock)
 	cv_broadcast(((struct lock *) lock)->lock_condvar);
 	mon_exit(((struct lock *) lock)->lock_monitor);
 }
-
-/*
- * Semaphore support.
- */
-PyThread_type_sema PyThread_allocate_sema(int value)
-{
-	PyThread_type_sema sema = 0;
-	dprintf(("PyThread_allocate_sema called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
-	return (PyThread_type_sema) sema;
-}
-
-void PyThread_free_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_free_sema(%p) called\n",  sema));
-}
-
-int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
-{
-	dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));
-	dprintf(("PyThread_down_sema(%p) return\n",  sema));
-	return -1;
-}
-
-void PyThread_up_sema(PyThread_type_sema sema)
-{
-	dprintf(("PyThread_up_sema(%p)\n",  sema));
-}
diff --git a/Python/thread_nt.h b/Python/thread_nt.h
@@ -319,56 +319,3 @@ void PyThread_release_lock(PyThread_type_lock aLock)
 	if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
 		dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 }
-
-/*
- * Semaphore support.
- */
-PyThread_type_sema PyThread_allocate_sema(int value)
-{
-	HANDLE aSemaphore;
-
-	dprintf(("%ld: PyThread_allocate_sema called\n", PyThread_get_thread_ident()));
-	if (!initialized)
-		PyThread_init_thread();
-
-	aSemaphore = CreateSemaphore( NULL,           /* Security attributes          */
-	                              value,          /* Initial value                */
-	                              INT_MAX,        /* Maximum value                */
-	                              NULL);          /* Name of semaphore            */
-
-	dprintf(("%ld: PyThread_allocate_sema() -> %p\n", PyThread_get_thread_ident(), aSemaphore));
-
-	return (PyThread_type_sema) aSemaphore;
-}
-
-void PyThread_free_sema(PyThread_type_sema aSemaphore)
-{
-	dprintf(("%ld: PyThread_free_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
-
-	CloseHandle((HANDLE) aSemaphore);
-}
-
-/*
-  XXX must do something about waitflag
- */
-int PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
-{
-	DWORD waitResult;
-
-	dprintf(("%ld: PyThread_down_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
-
-	waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE);
-
-	dprintf(("%ld: PyThread_down_sema(%p) return: %l\n", PyThread_get_thread_ident(), aSemaphore, waitResult));
-	return 0;
-}
-
-void PyThread_up_sema(PyThread_type_sema aSemaphore)
-{
-	ReleaseSemaphore(
-                (HANDLE) aSemaphore,            /* Handle of semaphore                          */
-                1,                              /* increment count by one                       */
-                NULL);                          /* not interested in previous count             */
-                                                
-	dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
-}
diff --git a/Python/thread_os2.h b/Python/thread_os2.h
@@ -209,30 +209,3 @@ void PyThread_release_lock(PyThread_type_lock aLock)
   
   DosExitCritSec();
 }
-
-/*
- * Semaphore support.
- */
-PyThread_type_sema 
-PyThread_allocate_sema(int value)
-{
-  return (PyThread_type_sema) 0;
-}
-
-void 
-PyThread_free_sema(PyThread_type_sema aSemaphore)
-{
-
-}
-
-int 
-PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
-{
-  return -1;
-}
-
-void 
-PyThread_up_sema(PyThread_type_sema aSemaphore)
-{
-  dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
-}
diff --git a/Python/thread_pth.h b/Python/thread_pth.h
@@ -206,90 +206,3 @@ void PyThread_release_lock(PyThread_type_lock lock)
         status = pth_cond_notify( &thelock->lock_released, 0 );
         CHECK_STATUS("pth_cond_notify");
 }
-
-/*
- * Semaphore support.
- */
-
-struct semaphore {
-	pth_mutex_t mutex;
-	pth_cond_t cond;
-	int value;
-};
-
-PyThread_type_sema PyThread_allocate_sema(int value)
-{
-	struct semaphore *sema;
-	int status, error = 0;
-
-	dprintf(("PyThread_allocate_sema called\n"));
-	if (!initialized)
-		PyThread_init_thread();
-
-	sema = (struct semaphore *) malloc(sizeof(struct semaphore));
-	if (sema != NULL) {
-		sema->value = value;
-		status = pth_mutex_init(&sema->mutex);
-		CHECK_STATUS("pth_mutex_init");
-		status = pth_cond_init(&sema->cond);
-		CHECK_STATUS("pth_mutex_init");
-		if (error) {
-			free((void *) sema);
-			sema = NULL;
-		}
-	}
-	dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
-	return (PyThread_type_sema) sema;
-}
-
-void PyThread_free_sema(PyThread_type_sema sema)
-{
-	struct semaphore *thesema = (struct semaphore *) sema;
-
-	dprintf(("PyThread_free_sema(%p) called\n",  sema));
-	free((void *) thesema);
-}
-
-int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
-{
-	int status, error = 0, success;
-	struct semaphore *thesema = (struct semaphore *) sema;
-
-	dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));
-	status = pth_mutex_acquire(&thesema->mutex, !waitflag, NULL);
-	CHECK_STATUS("pth_mutex_acquire");
-	if (waitflag) {
-		while (!error && thesema->value <= 0) {
-			status = pth_cond_await(&thesema->cond,
-						&thesema->mutex, NULL);
-			CHECK_STATUS("pth_cond_await");
-		}
-	}
-	if (error)
-		success = 0;
-	else if (thesema->value > 0) {
-		thesema->value--;
-		success = 1;
-	}
-	else
-		success = 0;
-	status = pth_mutex_release(&thesema->mutex);
-	CHECK_STATUS("pth_mutex_release");
-	dprintf(("PyThread_down_sema(%p) return\n",  sema));
-	return success;
-}
-
-void PyThread_up_sema(PyThread_type_sema sema)
-{
-	int status, error = 0;
-	struct semaphore *thesema = (struct semaphore *) sema;
-
-	dprintf(("PyThread_up_sema(%p)\n",  sema));
-	status = pth_mutex_acquire(&thesema->mutex, 0, NULL);
-	CHECK_STATUS("pth_mutex_acquire");
-	thesema->value++;
-	status = pth_cond_notify(&thesema->cond, 1);
-	CHECK_STATUS("pth_cond_notify");
-	status = pth_mutex_release(&thesema->mutex);
-	CHECK_STATUS("pth_mutex_release");
-}
diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h
diff --git a/Python/thread_sgi.h b/Python/thread_sgi.h
diff --git a/Python/thread_solaris.h b/Python/thread_solaris.h
