traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Issue #11863: remove unused file Python/thread_wince.h

This commit is contained in:
Antoine Pitrou 2011-07-08 23:37:39 +02:00
parent 910789f10f
commit 022ae22cc6
1 changed files with 0 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
Python/thread_wince.h
View File

@ -1,136 +0,0 @@
/* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */
#include <windows.h>
#include <limits.h>
#include <pydebug.h>
long PyThread_get_thread_ident(void);
/*
* Change all headers to pure ANSI as no one will use K&R style on an
* NT
*/
/*
* Initialization of the C package, should not be needed.
*/
static void PyThread__init_thread(void)
{
}
/*
* Thread support.
*/
long PyThread_start_new_thread(void (*func)(void *), void *arg)
{
long rv;
int success = -1;
dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
if (!initialized)
PyThread_init_thread();
rv = _beginthread(func, 0, arg); /* use default stack size */
if (rv != -1) {
success = 0;
dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
}
return success;
}
/*
* Return the thread Id instead of an handle. The Id is said to uniquely identify the
* thread in the system
*/
long PyThread_get_thread_ident(void)
{
if (!initialized)
PyThread_init_thread();
return GetCurrentThreadId();
}
void PyThread_exit_thread(void)
{
dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
if (!initialized)
exit(0);
_endthread();
}
/*
* Lock support. It has to be implemented using Mutexes, as
* CE doesnt support semaphores. Therefore we use some hacks to
* simulate the non reentrant requirements of Python locks
*/
PyThread_type_lock PyThread_allocate_lock(void)
{
HANDLE aLock;
dprintf(("PyThread_allocate_lock called\n"));
if (!initialized)
PyThread_init_thread();
aLock = CreateEvent(NULL, /* Security attributes */
0, /* Manual-Reset */
1, /* Is initially signalled */
NULL); /* Name of event */
dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
return (PyThread_type_lock) aLock;
}
void PyThread_free_lock(PyThread_type_lock aLock)
{
dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
CloseHandle(aLock);
}
/*
* Return 1 on success if the lock was acquired
*
* and 0 if the lock was not acquired. This means a 0 is returned
* if the lock has already been acquired by this thread!
*/
int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
{
int success = 1;
DWORD waitResult;
dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
#ifndef DEBUG
waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));
#else
/* To aid in debugging, we regularly wake up. This allows us to
break into the debugger */
while (TRUE) {
waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
break;
}
#endif
if (waitResult != WAIT_OBJECT_0) {
success = 0; /* We failed */
}
dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
return success;
}
void PyThread_release_lock(PyThread_type_lock aLock)
{
dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
if (!SetEvent(aLock))
dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
}