blob: 38ead1291283e7ef8255c18d502333ea760a6914 [file] [log] [blame]
Guido van Rossumb738d261999-04-08 13:57:06 +00001/***********************************************************
2Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
3The Netherlands.
4
5 All Rights Reserved
6
7Permission to use, copy, modify, and distribute this software and its
8documentation for any purpose and without fee is hereby granted,
9provided that the above copyright notice appear in all copies and that
10both that copyright notice and this permission notice appear in
11supporting documentation, and that the names of Stichting Mathematisch
12Centrum or CWI or Corporation for National Research Initiatives or
13CNRI not be used in advertising or publicity pertaining to
14distribution of the software without specific, written prior
15permission.
16
17While CWI is the initial source for this software, a modified version
18is made available by the Corporation for National Research Initiatives
19(CNRI) at the Internet address ftp://ftp.python.org.
20
21STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
22REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
23MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
24CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
25DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
26PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
27TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
28PERFORMANCE OF THIS SOFTWARE.
29
30******************************************************************/
31
32/* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */
33
34#include <windows.h>
35#include <limits.h>
36#include <pydebug.h>
37
38long PyThread_get_thread_ident(void);
39
40/*
41 * Change all headers to pure ANSI as no one will use K&R style on an
42 * NT
43 */
44
45/*
46 * Initialization of the C package, should not be needed.
47 */
48static void PyThread__init_thread(void)
49{
50}
51
52/*
53 * Thread support.
54 */
55int PyThread_start_new_thread(void (*func)(void *), void *arg)
56{
57 long rv;
58 int success = 0;
59
60 dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
61 if (!initialized)
62 PyThread_init_thread();
63
64 rv = _beginthread(func, 0, arg); /* use default stack size */
65
66 if (rv != -1) {
67 success = 1;
68 dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
69 }
70
71 return success;
72}
73
74/*
75 * Return the thread Id instead of an handle. The Id is said to uniquely identify the
76 * thread in the system
77 */
78long PyThread_get_thread_ident(void)
79{
80 if (!initialized)
81 PyThread_init_thread();
82
83 return GetCurrentThreadId();
84}
85
86static void do_PyThread_exit_thread(int no_cleanup)
87{
88 dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident()));
89 if (!initialized)
90 if (no_cleanup)
91 exit(0); /* XXX - was _exit()!! */
92 else
93 exit(0);
94 _endthread();
95}
96
97void PyThread_exit_thread(void)
98{
99 do_PyThread_exit_thread(0);
100}
101
102void PyThread__exit_thread(void)
103{
104 do_PyThread_exit_thread(1);
105}
106
107#ifndef NO_EXIT_PROG
108static void do_PyThread_exit_prog(int status, int no_cleanup)
109{
110 dprintf(("PyThread_exit_prog(%d) called\n", status));
111 if (!initialized)
112 if (no_cleanup)
113 _exit(status);
114 else
115 exit(status);
116}
117
118void PyThread_exit_prog(int status)
119{
120 do_PyThread_exit_prog(status, 0);
121}
122
123void PyThread__exit_prog _P1(int status)
124{
125 do_PyThread_exit_prog(status, 1);
126}
127#endif /* NO_EXIT_PROG */
128
129/*
130 * Lock support. It has to be implemented using Mutexes, as
131 * CE doesnt support semaphores. Therefore we use some hacks to
132 * simulate the non reentrant requirements of Python locks
133 */
134PyThread_type_lock PyThread_allocate_lock(void)
135{
136 HANDLE aLock;
137
138 dprintf(("PyThread_allocate_lock called\n"));
139 if (!initialized)
140 PyThread_init_thread();
141
142 aLock = CreateEvent(NULL, /* Security attributes */
143 0, /* Manual-Reset */
144 1, /* Is initially signalled */
145 NULL); /* Name of event */
146
147 dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", PyThread_get_thread_ident(), (long)aLock));
148
149 return (PyThread_type_lock) aLock;
150}
151
152void PyThread_free_lock(PyThread_type_lock aLock)
153{
154 dprintf(("%ld: PyThread_free_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
155
156 CloseHandle(aLock);
157}
158
159/*
160 * Return 1 on success if the lock was acquired
161 *
162 * and 0 if the lock was not acquired. This means a 0 is returned
163 * if the lock has already been acquired by this thread!
164 */
165int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
166{
167 int success = 1;
168 DWORD waitResult;
169
170 dprintf(("%ld: PyThread_acquire_lock(%lx, %d) called\n", PyThread_get_thread_ident(),(long)aLock, waitflag));
171
172#ifndef DEBUG
173 waitResult = WaitForSingleObject(aLock, (waitflag == 1 ? INFINITE : 0));
174#else
175 /* To aid in debugging, we regularly wake up. This allows us to
176 break into the debugger */
177 while (TRUE) {
178 waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
179 if (waitflag==0 || (waitflag==1 && waitResult == WAIT_OBJECT_0))
180 break;
181 }
182#endif
183
184 if (waitResult != WAIT_OBJECT_0) {
185 success = 0; /* We failed */
186 }
187
188 dprintf(("%ld: PyThread_acquire_lock(%lx, %d) -> %d\n", PyThread_get_thread_ident(),(long)aLock, waitflag, success));
189
190 return success;
191}
192
193void PyThread_release_lock(PyThread_type_lock aLock)
194{
195 dprintf(("%ld: PyThread_release_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
196
197 if (!SetEvent(aLock))
198 dprintf(("%ld: Could not PyThread_release_lock(%lx) error: %l\n", PyThread_get_thread_ident(), (long)aLock, GetLastError()));
199}
200
201