Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 1 | /*********************************************************** |
| 2 | Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam, |
| 3 | The Netherlands. |
| 4 | |
| 5 | All Rights Reserved |
| 6 | |
Guido van Rossum | d266eb4 | 1996-10-25 14:44:06 +0000 | [diff] [blame^] | 7 | Permission to use, copy, modify, and distribute this software and its |
| 8 | documentation for any purpose and without fee is hereby granted, |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 9 | provided that the above copyright notice appear in all copies and that |
Guido van Rossum | d266eb4 | 1996-10-25 14:44:06 +0000 | [diff] [blame^] | 10 | both that copyright notice and this permission notice appear in |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 11 | supporting documentation, and that the names of Stichting Mathematisch |
Guido van Rossum | d266eb4 | 1996-10-25 14:44:06 +0000 | [diff] [blame^] | 12 | Centrum or CWI or Corporation for National Research Initiatives or |
| 13 | CNRI not be used in advertising or publicity pertaining to |
| 14 | distribution of the software without specific, written prior |
| 15 | permission. |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 16 | |
Guido van Rossum | d266eb4 | 1996-10-25 14:44:06 +0000 | [diff] [blame^] | 17 | While CWI is the initial source for this software, a modified version |
| 18 | is made available by the Corporation for National Research Initiatives |
| 19 | (CNRI) at the Internet address ftp://ftp.python.org. |
| 20 | |
| 21 | STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH |
| 22 | REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF |
| 23 | MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH |
| 24 | CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL |
| 25 | DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| 26 | PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| 27 | TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| 28 | PERFORMANCE OF THIS SOFTWARE. |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 29 | |
| 30 | ******************************************************************/ |
| 31 | |
| 32 | /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */ |
| 33 | |
| 34 | #include "windows.h" |
| 35 | #include "limits.h" |
| 36 | |
| 37 | long get_thread_ident(void); |
| 38 | |
| 39 | /* |
| 40 | * Change all headers to pure ANSI as no one will use K&R style on an |
| 41 | * NT |
| 42 | */ |
| 43 | |
| 44 | /* |
| 45 | * Initialization of the C package, should not be needed. |
| 46 | */ |
| 47 | static void _init_thread(void) |
| 48 | { |
| 49 | } |
| 50 | |
| 51 | /* |
| 52 | * Thread support. |
| 53 | */ |
| 54 | int start_new_thread(void (*func)(void *), void *arg) |
| 55 | { |
| 56 | HANDLE aThread; |
| 57 | DWORD aThreadId; |
| 58 | |
| 59 | int success = 0; /* init not needed when SOLARIS_THREADS and */ |
| 60 | /* C_THREADS implemented properly */ |
| 61 | dprintf(("%ld: start_new_thread called\n", get_thread_ident())); |
| 62 | if (!initialized) |
| 63 | init_thread(); |
| 64 | |
| 65 | aThread = CreateThread( |
| 66 | NULL, /* No security attributes */ |
| 67 | 0, /* use default stack size */ |
| 68 | (LPTHREAD_START_ROUTINE) func, /* thread function */ |
| 69 | (LPVOID) arg, /* argument to thread function */ |
| 70 | 0, /* use the default creation flags */ |
| 71 | &aThreadId); /* returns the thread identifier */ |
| 72 | |
| 73 | if (aThread != NULL) { |
| 74 | CloseHandle(aThread); /* We do not want to have any zombies hanging around */ |
| 75 | success = 1; |
| 76 | dprintf(("%ld: start_new_thread succeeded: %ld\n", get_thread_ident(), aThreadId)); |
| 77 | } |
| 78 | |
| 79 | return success; |
| 80 | } |
| 81 | |
| 82 | /* |
| 83 | * Return the thread Id instead of an handle. The Id is said to uniquely identify the |
| 84 | * thread in the system |
| 85 | */ |
| 86 | long get_thread_ident(void) |
| 87 | { |
| 88 | if (!initialized) |
| 89 | init_thread(); |
| 90 | |
| 91 | return GetCurrentThreadId(); |
| 92 | } |
| 93 | |
| 94 | static void do_exit_thread(int no_cleanup) |
| 95 | { |
| 96 | dprintf(("%ld: exit_thread called\n", get_thread_ident())); |
| 97 | if (!initialized) |
| 98 | if (no_cleanup) |
| 99 | _exit(0); |
| 100 | else |
| 101 | exit(0); |
| 102 | ExitThread(0); |
| 103 | } |
| 104 | |
| 105 | void exit_thread(void) |
| 106 | { |
| 107 | do_exit_thread(0); |
| 108 | } |
| 109 | |
| 110 | void _exit_thread(void) |
| 111 | { |
| 112 | do_exit_thread(1); |
| 113 | } |
| 114 | |
| 115 | #ifndef NO_EXIT_PROG |
| 116 | static void do_exit_prog(int status, int no_cleanup) |
| 117 | { |
| 118 | dprintf(("exit_prog(%d) called\n", status)); |
| 119 | if (!initialized) |
| 120 | if (no_cleanup) |
| 121 | _exit(status); |
| 122 | else |
| 123 | exit(status); |
| 124 | } |
| 125 | |
| 126 | void exit_prog(int status) |
| 127 | { |
| 128 | do_exit_prog(status, 0); |
| 129 | } |
| 130 | |
| 131 | void _exit_prog _P1(int status) |
| 132 | { |
| 133 | do_exit_prog(status, 1); |
| 134 | } |
| 135 | #endif /* NO_EXIT_PROG */ |
| 136 | |
| 137 | /* |
| 138 | * Lock support. It has too be implemented as semaphores. |
| 139 | * I [Dag] tried to implement it with mutex but I could find a way to |
| 140 | * tell whether a thread already own the lock or not. |
| 141 | */ |
| 142 | type_lock allocate_lock(void) |
| 143 | { |
| 144 | HANDLE aLock; |
| 145 | |
| 146 | dprintf(("allocate_lock called\n")); |
| 147 | if (!initialized) |
| 148 | init_thread(); |
| 149 | |
| 150 | aLock = CreateSemaphore(NULL, /* Security attributes */ |
| 151 | 1, /* Initial value */ |
| 152 | 1, /* Maximum value */ |
| 153 | NULL); |
| 154 | /* Name of semaphore */ |
| 155 | |
| 156 | dprintf(("%ld: allocate_lock() -> %lx\n", get_thread_ident(), (long)aLock)); |
| 157 | |
| 158 | return (type_lock) aLock; |
| 159 | } |
| 160 | |
| 161 | void free_lock(type_lock aLock) |
| 162 | { |
| 163 | dprintf(("%ld: free_lock(%lx) called\n", get_thread_ident(),(long)aLock)); |
| 164 | |
| 165 | CloseHandle((HANDLE) aLock); |
| 166 | } |
| 167 | |
| 168 | /* |
| 169 | * Return 1 on success if the lock was acquired |
| 170 | * |
| 171 | * and 0 if the lock was not acquired. This means a 0 is returned |
| 172 | * if the lock has already been acquired by this thread! |
| 173 | */ |
| 174 | int acquire_lock(type_lock aLock, int waitflag) |
| 175 | { |
| 176 | int success = 1; |
| 177 | DWORD waitResult; |
| 178 | |
| 179 | dprintf(("%ld: acquire_lock(%lx, %d) called\n", get_thread_ident(),(long)aLock, waitflag)); |
| 180 | |
| 181 | waitResult = WaitForSingleObject((HANDLE) aLock, (waitflag == 1 ? INFINITE : 0)); |
| 182 | |
| 183 | if (waitResult != WAIT_OBJECT_0) { |
| 184 | success = 0; /* We failed */ |
| 185 | } |
| 186 | |
| 187 | dprintf(("%ld: acquire_lock(%lx, %d) -> %d\n", get_thread_ident(),(long)aLock, waitflag, success)); |
| 188 | |
| 189 | return success; |
| 190 | } |
| 191 | |
| 192 | void release_lock(type_lock aLock) |
| 193 | { |
| 194 | dprintf(("%ld: release_lock(%lx) called\n", get_thread_ident(),(long)aLock)); |
| 195 | |
| 196 | if (!ReleaseSemaphore( |
| 197 | (HANDLE) aLock, /* Handle of semaphore */ |
| 198 | 1, /* increment count by one */ |
| 199 | NULL)) /* not interested in previous count */ |
| 200 | { |
| 201 | dprintf(("%ld: Could not release_lock(%lx) error: %l\n", get_thread_ident(), (long)aLock, GetLastError())); |
| 202 | } |
| 203 | } |
| 204 | |
| 205 | /* |
| 206 | * Semaphore support. |
| 207 | */ |
| 208 | type_sema allocate_sema(int value) |
| 209 | { |
| 210 | HANDLE aSemaphore; |
| 211 | |
| 212 | dprintf(("%ld: allocate_sema called\n", get_thread_ident())); |
| 213 | if (!initialized) |
| 214 | init_thread(); |
| 215 | |
| 216 | aSemaphore = CreateSemaphore( NULL, /* Security attributes */ |
| 217 | value, /* Initial value */ |
| 218 | INT_MAX, /* Maximum value */ |
| 219 | NULL); /* Name of semaphore */ |
| 220 | |
| 221 | dprintf(("%ld: allocate_sema() -> %lx\n", get_thread_ident(), (long)aSemaphore)); |
| 222 | |
| 223 | return (type_sema) aSemaphore; |
| 224 | } |
| 225 | |
| 226 | void free_sema(type_sema aSemaphore) |
| 227 | { |
| 228 | dprintf(("%ld: free_sema(%lx) called\n", get_thread_ident(), (long)aSemaphore)); |
| 229 | |
| 230 | CloseHandle((HANDLE) aSemaphore); |
| 231 | } |
| 232 | |
Guido van Rossum | cf1474b | 1996-10-08 14:17:53 +0000 | [diff] [blame] | 233 | /* |
| 234 | XXX must do something about waitflag |
| 235 | */ |
| 236 | int down_sema(type_sema aSemaphore, int waitflag) |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 237 | { |
| 238 | DWORD waitResult; |
| 239 | |
| 240 | dprintf(("%ld: down_sema(%lx) called\n", get_thread_ident(), (long)aSemaphore)); |
| 241 | |
| 242 | waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE); |
| 243 | |
| 244 | dprintf(("%ld: down_sema(%lx) return: %l\n", get_thread_ident(),(long) aSemaphore, waitResult)); |
Guido van Rossum | cf1474b | 1996-10-08 14:17:53 +0000 | [diff] [blame] | 245 | return 0; |
Guido van Rossum | c3f82b6 | 1995-01-17 16:29:31 +0000 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | void up_sema(type_sema aSemaphore) |
| 249 | { |
| 250 | ReleaseSemaphore( |
| 251 | (HANDLE) aSemaphore, /* Handle of semaphore */ |
| 252 | 1, /* increment count by one */ |
| 253 | NULL); /* not interested in previous count */ |
| 254 | |
| 255 | dprintf(("%ld: up_sema(%lx)\n", get_thread_ident(), (long)aSemaphore)); |
| 256 | } |