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