summaryrefslogtreecommitdiffstats
path: root/Modules
diff options
context:
space:
mode:
Diffstat (limited to 'Modules')
-rw-r--r--Modules/_tkinter.c22
-rw-r--r--Modules/bsddbmodule.c18
-rw-r--r--Modules/signalmodule.c10
-rw-r--r--Modules/socketmodule.c16
-rw-r--r--Modules/stdwinmodule.c10
-rw-r--r--Modules/threadmodule.c79
6 files changed, 74 insertions, 81 deletions
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index 9d68c69..46bf8da 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -171,29 +171,29 @@ PERFORMANCE OF THIS SOFTWARE.
*/
-static type_lock tcl_lock = 0;
+static PyThread_type_lock tcl_lock = 0;
static PyThreadState *tcl_tstate = NULL;
#define ENTER_TCL \
{ PyThreadState *tstate = PyThreadState_Get(); Py_BEGIN_ALLOW_THREADS \
- acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
+ PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate;
#define LEAVE_TCL \
- tcl_tstate = NULL; release_lock(tcl_lock); Py_END_ALLOW_THREADS}
+ tcl_tstate = NULL; PyThread_release_lock(tcl_lock); Py_END_ALLOW_THREADS}
#define ENTER_OVERLAP \
Py_END_ALLOW_THREADS
#define LEAVE_OVERLAP_TCL \
- tcl_tstate = NULL; release_lock(tcl_lock); }
+ tcl_tstate = NULL; PyThread_release_lock(tcl_lock); }
#define ENTER_PYTHON \
{ PyThreadState *tstate = tcl_tstate; tcl_tstate = NULL; \
- release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
+ PyThread_release_lock(tcl_lock); PyEval_RestoreThread((tstate)); }
#define LEAVE_PYTHON \
{ PyThreadState *tstate = PyEval_SaveThread(); \
- acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
+ PyThread_acquire_lock(tcl_lock, 1); tcl_tstate = tstate; }
#else
@@ -1679,11 +1679,11 @@ Tkapp_MainLoop(self, args)
#ifdef WITH_THREAD
Py_BEGIN_ALLOW_THREADS
- acquire_lock(tcl_lock, 1);
+ PyThread_acquire_lock(tcl_lock, 1);
tcl_tstate = tstate;
result = Tcl_DoOneEvent(TCL_DONT_WAIT);
tcl_tstate = NULL;
- release_lock(tcl_lock);
+ PyThread_release_lock(tcl_lock);
if (result == 0)
Sleep(20);
Py_END_ALLOW_THREADS
@@ -1921,13 +1921,13 @@ EventHook()
#endif
#if defined(WITH_THREAD) || defined(MS_WINDOWS)
Py_BEGIN_ALLOW_THREADS
- acquire_lock(tcl_lock, 1);
+ PyThread_acquire_lock(tcl_lock, 1);
tcl_tstate = event_tstate;
result = Tcl_DoOneEvent(TCL_DONT_WAIT);
tcl_tstate = NULL;
- release_lock(tcl_lock);
+ PyThread_release_lock(tcl_lock);
if (result == 0)
Sleep(20);
Py_END_ALLOW_THREADS
@@ -2014,7 +2014,7 @@ init_tkinter()
Tkapp_Type.ob_type = &PyType_Type;
#ifdef WITH_THREAD
- tcl_lock = allocate_lock();
+ tcl_lock = PyThread_allocate_lock();
#endif
m = Py_InitModule("_tkinter", moduleMethods);
diff --git a/Modules/bsddbmodule.c b/Modules/bsddbmodule.c
index 1bb40e6..ef20624 100644
--- a/Modules/bsddbmodule.c
+++ b/Modules/bsddbmodule.c
@@ -57,7 +57,7 @@ typedef struct {
DB *di_bsddb;
int di_size; /* -1 means recompute */
#ifdef WITH_THREAD
- type_lock di_lock;
+ PyThread_type_lock di_lock;
#endif
} bsddbobject;
@@ -113,7 +113,7 @@ newdbhashobject(file, flags, mode,
dp->di_size = -1;
#ifdef WITH_THREAD
- dp->di_lock = allocate_lock();
+ dp->di_lock = PyThread_allocate_lock();
if (dp->di_lock == NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
@@ -169,7 +169,7 @@ newdbbtobject(file, flags, mode,
dp->di_size = -1;
#ifdef WITH_THREAD
- dp->di_lock = allocate_lock();
+ dp->di_lock = PyThread_allocate_lock();
if (dp->di_lock == NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
@@ -225,7 +225,7 @@ newdbrnobject(file, flags, mode,
dp->di_size = -1;
#ifdef WITH_THREAD
- dp->di_lock = allocate_lock();
+ dp->di_lock = PyThread_allocate_lock();
if (dp->di_lock == NULL) {
PyErr_SetString(BsddbError, "can't allocate lock");
Py_DECREF(dp);
@@ -242,9 +242,9 @@ bsddb_dealloc(dp)
{
#ifdef WITH_THREAD
if (dp->di_lock) {
- acquire_lock(dp->di_lock, 0);
- release_lock(dp->di_lock);
- free_lock(dp->di_lock);
+ PyThread_acquire_lock(dp->di_lock, 0);
+ PyThread_release_lock(dp->di_lock);
+ PyThread_free_lock(dp->di_lock);
dp->di_lock = NULL;
}
#endif
@@ -262,8 +262,8 @@ bsddb_dealloc(dp)
}
#ifdef WITH_THREAD
-#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS acquire_lock(_dp->di_lock,1);
-#define BSDDB_END_SAVE(_dp) release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
+#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_dp->di_lock,1);
+#define BSDDB_END_SAVE(_dp) PyThread_release_lock(_dp->di_lock); Py_END_ALLOW_THREADS
#else
#define BSDDB_BGN_SAVE(_dp) Py_BEGIN_ALLOW_THREADS
#define BSDDB_END_SAVE(_dp) Py_END_ALLOW_THREADS
diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c
index 11b624a..26bb940 100644
--- a/Modules/signalmodule.c
+++ b/Modules/signalmodule.c
@@ -221,7 +221,7 @@ signal_signal(self, args)
if (!PyArg_Parse(args, "(iO)", &sig_num, &obj))
return NULL;
#ifdef WITH_THREAD
- if (get_thread_ident() != main_thread) {
+ if (PyThread_get_thread_ident() != main_thread) {
PyErr_SetString(PyExc_ValueError,
"signal only works in main thread");
return NULL;
@@ -346,7 +346,7 @@ initsignal()
int i;
#ifdef WITH_THREAD
- main_thread = get_thread_ident();
+ main_thread = PyThread_get_thread_ident();
main_pid = getpid();
#endif
@@ -619,7 +619,7 @@ PyErr_CheckSignals()
if (!is_tripped)
return 0;
#ifdef WITH_THREAD
- if (get_thread_ident() != main_thread)
+ if (PyThread_get_thread_ident() != main_thread)
return 0;
#endif
if (!(f = PyEval_GetFrame()))
@@ -676,7 +676,7 @@ PyOS_InterruptOccurred()
{
if (Handlers[SIGINT].tripped) {
#ifdef WITH_THREAD
- if (get_thread_ident() != main_thread)
+ if (PyThread_get_thread_ident() != main_thread)
return 0;
#endif
Handlers[SIGINT].tripped = 0;
@@ -689,7 +689,7 @@ void
PyOS_AfterFork()
{
#ifdef WITH_THREAD
- main_thread = get_thread_ident();
+ main_thread = PyThread_get_thread_ident();
main_pid = getpid();
#endif
}
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 0564e17..ab0014c 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -313,7 +313,7 @@ BUILD_FUNC_DEF_4(PySocketSock_New,int,fd, int,family, int,type, int,proto)
/* Lock to allow python interpreter to continue, but only allow one
thread to be in gethostbyname */
#if defined(WITH_THREAD) && !defined(HAVE_GETHOSTBYNAME_R) && !defined(MS_WINDOWS)
-type_lock gethostbyname_lock;
+PyThread_type_lock gethostbyname_lock;
#endif
@@ -358,11 +358,11 @@ BUILD_FUNC_DEF_2(setipaddr, char*,name, struct sockaddr_in *,addr_ret)
hp = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
#else /* not HAVE_GETHOSTBYNAME_R */
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- acquire_lock(gethostbyname_lock,1);
+ PyThread_acquire_lock(gethostbyname_lock,1);
#endif
hp = gethostbyname(name);
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- release_lock(gethostbyname_lock);
+ PyThread_release_lock(gethostbyname_lock);
#endif
#endif /* HAVE_GETHOSTBYNAME_R */
Py_END_ALLOW_THREADS
@@ -1417,11 +1417,11 @@ BUILD_FUNC_DEF_2(PySocket_gethostbyname_ex,PyObject *,self, PyObject *,args)
h = gethostbyname_r(name, &hp_allocated, buf, buf_len, &errnop);
#else /* not HAVE_GETHOSTBYNAME_R */
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- acquire_lock(gethostbyname_lock,1);
+ PyThread_acquire_lock(gethostbyname_lock,1);
#endif
h = gethostbyname(name);
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- release_lock(gethostbyname_lock);
+ PyThread_release_lock(gethostbyname_lock);
#endif
#endif /* HAVE_GETHOSTBYNAME_R */
Py_END_ALLOW_THREADS
@@ -1463,13 +1463,13 @@ BUILD_FUNC_DEF_2(PySocket_gethostbyaddr,PyObject *,self, PyObject *, args)
&hp_allocated, buf, buf_len, &errnop);
#else /* not HAVE_GETHOSTBYNAME_R */
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- acquire_lock(gethostbyname_lock,1);
+ PyThread_acquire_lock(gethostbyname_lock,1);
#endif
h = gethostbyaddr((char *)&addr.sin_addr,
sizeof(addr.sin_addr),
AF_INET);
#if defined(WITH_THREAD) && !defined(MS_WINDOWS)
- release_lock(gethostbyname_lock);
+ PyThread_release_lock(gethostbyname_lock);
#endif
#endif /* HAVE_GETHOSTBYNAME_R */
Py_END_ALLOW_THREADS
@@ -2188,6 +2188,6 @@ initsocket()
/* Initialize gethostbyname lock */
#if defined(WITH_THREAD) && !defined(HAVE_GETHOSTBYNAME_R) && !defined(MS_WINDOWS)
- gethostbyname_lock = allocate_lock();
+ gethostbyname_lock = PyThread_allocate_lock();
#endif
}
diff --git a/Modules/stdwinmodule.c b/Modules/stdwinmodule.c
index 8b18f49..ffae730 100644
--- a/Modules/stdwinmodule.c
+++ b/Modules/stdwinmodule.c
@@ -87,11 +87,11 @@ PERFORMANCE OF THIS SOFTWARE.
#include "pythread.h"
-static type_lock StdwinLock; /* Lock held when interpreter not locked */
+static PyThread_type_lock StdwinLock; /* Lock held when interpreter not locked */
-#define BGN_STDWIN Py_BEGIN_ALLOW_THREADS acquire_lock(StdwinLock, 1);
-#define RET_STDWIN release_lock(StdwinLock); Py_BLOCK_THREADS
-#define END_STDWIN release_lock(StdwinLock); Py_END_ALLOW_THREADS
+#define BGN_STDWIN Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(StdwinLock, 1);
+#define RET_STDWIN PyThread_release_lock(StdwinLock); Py_BLOCK_THREADS
+#define END_STDWIN PyThread_release_lock(StdwinLock); Py_END_ALLOW_THREADS
#else
@@ -2659,6 +2659,6 @@ initstdwin()
PyDict_SetItemString(d, "error", StdwinError) != 0)
return;
#ifdef WITH_THREAD
- StdwinLock = allocate_lock();
+ StdwinLock = PyThread_allocate_lock();
#endif
}
diff --git a/Modules/threadmodule.c b/Modules/threadmodule.c
index b08ff0b..3d5e4cc 100644
--- a/Modules/threadmodule.c
+++ b/Modules/threadmodule.c
@@ -49,7 +49,7 @@ static PyObject *ThreadError;
typedef struct {
PyObject_HEAD
- type_lock lock_lock;
+ PyThread_type_lock lock_lock;
} lockobject;
staticforward PyTypeObject Locktype;
@@ -61,7 +61,7 @@ newlockobject()
self = PyObject_NEW(lockobject, &Locktype);
if (self == NULL)
return NULL;
- self->lock_lock = allocate_lock();
+ self->lock_lock = PyThread_allocate_lock();
if (self->lock_lock == NULL) {
PyMem_DEL(self);
self = NULL;
@@ -75,15 +75,15 @@ lock_dealloc(self)
lockobject *self;
{
/* Unlock the lock so it's safe to free it */
- acquire_lock(self->lock_lock, 0);
- release_lock(self->lock_lock);
+ PyThread_acquire_lock(self->lock_lock, 0);
+ PyThread_release_lock(self->lock_lock);
- free_lock(self->lock_lock);
+ PyThread_free_lock(self->lock_lock);
PyMem_DEL(self);
}
static PyObject *
-lock_acquire_lock(self, args)
+lock_PyThread_acquire_lock(self, args)
lockobject *self;
PyObject *args;
{
@@ -97,7 +97,7 @@ lock_acquire_lock(self, args)
i = 1;
Py_BEGIN_ALLOW_THREADS
- i = acquire_lock(self->lock_lock, i);
+ i = PyThread_acquire_lock(self->lock_lock, i);
Py_END_ALLOW_THREADS
if (args == NULL) {
@@ -110,7 +110,7 @@ lock_acquire_lock(self, args)
static char acquire_doc[] =
"acquire([wait]) -> None or Boolean\n\
-(acquire_lock() is an obsolete synonym)\n\
+(PyThread_acquire_lock() is an obsolete synonym)\n\
\n\
Lock the lock. Without argument, this blocks if the lock is already\n\
locked (even by the same thread), waiting for another thread to release\n\
@@ -120,7 +120,7 @@ and the return value reflects whether the lock is acquired.\n\
The blocking operation is not interruptible.";
static PyObject *
-lock_release_lock(self, args)
+lock_PyThread_release_lock(self, args)
lockobject *self;
PyObject *args;
{
@@ -128,20 +128,20 @@ lock_release_lock(self, args)
return NULL;
/* Sanity check: the lock must be locked */
- if (acquire_lock(self->lock_lock, 0)) {
- release_lock(self->lock_lock);
+ if (PyThread_acquire_lock(self->lock_lock, 0)) {
+ PyThread_release_lock(self->lock_lock);
PyErr_SetString(ThreadError, "release unlocked lock");
return NULL;
}
- release_lock(self->lock_lock);
+ PyThread_release_lock(self->lock_lock);
Py_INCREF(Py_None);
return Py_None;
}
static char release_doc[] =
"release()\n\
-(release_lock() is an obsolete synonym)\n\
+(PyThread_release_lock() is an obsolete synonym)\n\
\n\
Release the lock, allowing another thread that is blocked waiting for\n\
the lock to acquire the lock. The lock must be in the locked state,\n\
@@ -155,8 +155,8 @@ lock_locked_lock(self, args)
if (!PyArg_NoArgs(args))
return NULL;
- if (acquire_lock(self->lock_lock, 0)) {
- release_lock(self->lock_lock);
+ if (PyThread_acquire_lock(self->lock_lock, 0)) {
+ PyThread_release_lock(self->lock_lock);
return PyInt_FromLong(0L);
}
return PyInt_FromLong(1L);
@@ -169,10 +169,10 @@ static char locked_doc[] =
Return whether the lock is in the locked state.";
static PyMethodDef lock_methods[] = {
- {"acquire_lock", (PyCFunction)lock_acquire_lock, 0, acquire_doc},
- {"acquire", (PyCFunction)lock_acquire_lock, 0, acquire_doc},
- {"release_lock", (PyCFunction)lock_release_lock, 0, release_doc},
- {"release", (PyCFunction)lock_release_lock, 0, release_doc},
+ {"acquire_lock", (PyCFunction)lock_PyThread_acquire_lock, 0, acquire_doc},
+ {"acquire", (PyCFunction)lock_PyThread_acquire_lock, 0, acquire_doc},
+ {"release_lock", (PyCFunction)lock_PyThread_release_lock, 0, release_doc},
+ {"release", (PyCFunction)lock_PyThread_release_lock, 0, release_doc},
{"locked_lock", (PyCFunction)lock_locked_lock, 0, locked_doc},
{"locked", (PyCFunction)lock_locked_lock, 0, locked_doc},
{NULL, NULL} /* sentinel */
@@ -240,18 +240,11 @@ t_bootstrap(boot_raw)
PyThreadState_Clear(tstate);
PyEval_ReleaseThread(tstate);
PyThreadState_Delete(tstate);
-#ifdef __BEOS__
- /* Dunno if this will cause problems with other ports; the BeOS thread
- * support features only 100% renamed functions. [cjh]
- */
PyThread_exit_thread();
-#else
- exit_thread();
-#endif
}
static PyObject *
-thread_start_new_thread(self, fargs)
+thread_PyThread_start_new_thread(self, fargs)
PyObject *self; /* Not used */
PyObject *fargs;
{
@@ -286,7 +279,7 @@ thread_start_new_thread(self, fargs)
Py_INCREF(args);
Py_XINCREF(keyw);
PyEval_InitThreads(); /* Start the interpreter's thread-awareness */
- if (!start_new_thread(t_bootstrap, (void*) boot)) {
+ if (!PyThread_start_new_thread(t_bootstrap, (void*) boot)) {
PyErr_SetString(ThreadError, "can't start new thread\n");
Py_DECREF(func);
Py_DECREF(args);
@@ -310,7 +303,7 @@ unhandled exception; a stack trace will be printed unless the exception is\n\
SystemExit.";
static PyObject *
-thread_exit_thread(self, args)
+thread_PyThread_exit_thread(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
@@ -322,27 +315,27 @@ thread_exit_thread(self, args)
static char exit_doc[] =
"exit()\n\
-(exit_thread() is an obsolete synonym)\n\
+(PyThread_exit_thread() is an obsolete synonym)\n\
\n\
This is synonymous to ``raise SystemExit''. It will cause the current\n\
thread to exit silently unless the exception is caught.";
#ifndef NO_EXIT_PROG
static PyObject *
-thread_exit_prog(self, args)
+thread_PyThread_exit_prog(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
int sts;
if (!PyArg_Parse(args, "i", &sts))
return NULL;
- Py_Exit(sts); /* Calls exit_prog(sts) or _exit_prog(sts) */
+ Py_Exit(sts); /* Calls PyThread_exit_prog(sts) or _PyThread_exit_prog(sts) */
for (;;) { } /* Should not be reached */
}
#endif
static PyObject *
-thread_allocate_lock(self, args)
+thread_PyThread_allocate_lock(self, args)
PyObject *self; /* Not used */
PyObject *args;
{
@@ -365,7 +358,7 @@ thread_get_ident(self, args)
long ident;
if (!PyArg_NoArgs(args))
return NULL;
- ident = get_thread_ident();
+ ident = PyThread_get_thread_ident();
if (ident == -1) {
PyErr_SetString(ThreadError, "no current thread ident");
return NULL;
@@ -385,22 +378,22 @@ be relied upon, and the number should be seen purely as a magic cookie.\n\
A thread's identity may be reused for another thread after it exits.";
static PyMethodDef thread_methods[] = {
- {"start_new_thread", (PyCFunction)thread_start_new_thread, 1,
+ {"start_new_thread", (PyCFunction)thread_PyThread_start_new_thread, 1,
start_new_doc},
- {"start_new", (PyCFunction)thread_start_new_thread, 1,
+ {"start_new", (PyCFunction)thread_PyThread_start_new_thread, 1,
start_new_doc},
- {"allocate_lock", (PyCFunction)thread_allocate_lock, 0,
+ {"allocate_lock", (PyCFunction)thread_PyThread_allocate_lock, 0,
allocate_doc},
- {"allocate", (PyCFunction)thread_allocate_lock, 0,
+ {"allocate", (PyCFunction)thread_PyThread_allocate_lock, 0,
allocate_doc},
- {"exit_thread", (PyCFunction)thread_exit_thread, 0,
+ {"exit_thread", (PyCFunction)thread_PyThread_exit_thread, 0,
exit_doc},
- {"exit", (PyCFunction)thread_exit_thread, 0,
+ {"exit", (PyCFunction)thread_PyThread_exit_thread, 0,
exit_doc},
{"get_ident", (PyCFunction)thread_get_ident, 0,
get_ident_doc},
#ifndef NO_EXIT_PROG
- {"exit_prog", (PyCFunction)thread_exit_prog},
+ {"exit_prog", (PyCFunction)thread_PyThread_exit_prog},
#endif
{NULL, NULL} /* sentinel */
};
@@ -414,7 +407,7 @@ The 'threading' module provides a more convenient interface.";
static char lock_doc[] =
"A lock object is a synchronization primitive. To create a lock,\n\
-call the allocate_lock() function. Methods are:\n\
+call the PyThread_allocate_lock() function. Methods are:\n\
\n\
acquire() -- lock the lock, possibly blocking until it can be obtained\n\
release() -- unlock of the lock\n\
@@ -441,5 +434,5 @@ initthread()
PyDict_SetItemString(d, "LockType", (PyObject *)&Locktype);
/* Initialize the C thread library */
- init_thread();
+ PyThread_init_thread();
}
generated by cgit v0.12 at 2024-12-01 05:03:32 (GMT)