Python/thread_wince.h

   1
   2 /* This code implemented by Mark Hammond (MHammond@skippinet.com.au) */
   3
   4 #include <windows.h>
   5 #include <limits.h>
   6 #include <pydebug.h>
   7
   8 long PyThread_get_thread_ident(void);
   9
  10 /*
  11  * Change all headers to pure ANSI as no one will use K&R style on an
  12  * NT
  13  */
  14
  15 /*
  16  * Initialization of the C package, should not be needed.
  17  */
  18 static void PyThread__init_thread(void)
  19 {
  20 }
  21
  22 /*
  23  * Thread support.
  24  */
  25 long PyThread_start_new_thread(void (*func)(void *), void *arg)
  26 {
  27         long rv;
  28         int success = -1;
  29
  30         dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
  31         if (!initialized)
  32                 PyThread_init_thread();
  33
  34         rv = _beginthread(func, 0, arg); /* use default stack size */
  35
  36         if (rv != -1) {
  37                 success = 0;
  38                 dprintf(("%ld: PyThread_start_new_thread succeeded:\n", PyThread_get_thread_ident()));
  39         }
  40
  41         return success;
  42 }
  43
  44 /*
  45  * Return the thread Id instead of an handle. The Id is said to uniquely identify the
  46  * thread in the system
  47  */
  48 long PyThread_get_thread_ident(void)
  49 {
  50         if (!initialized)
  51                 PyThread_init_thread();
  52
  53         return GetCurrentThreadId();
  54 }
  55
  56 static void do_PyThread_exit_thread(int no_cleanup)
  57 {
  58         dprintf(("%ld: do_PyThread_exit_thread called\n", PyThread_get_thread_ident()));
  59         if (!initialized)
  60                 if (no_cleanup)
  61                         exit(0); /* XXX - was _exit()!! */
  62                 else
  63                         exit(0);
  64         _endthread();
  65 }
  66
  67 void PyThread_exit_thread(void)
  68 {
  69         do_PyThread_exit_thread(0);
  70 }
  71
  72 void PyThread__exit_thread(void)
  73 {
  74         do_PyThread_exit_thread(1);
  75 }
  76
  77 #ifndef NO_EXIT_PROG
  78 static void do_PyThread_exit_prog(int status, int no_cleanup)
  79 {
  80         dprintf(("PyThread_exit_prog(%d) called\n", status));
  81         if (!initialized)
  82                 if (no_cleanup)
  83                         _exit(status);
  84                 else
  85                         exit(status);
  86 }
  87
  88 void PyThread_exit_prog(int status)
  89 {
  90         do_PyThread_exit_prog(status, 0);
  91 }
  92
  93 void PyThread__exit_prog(int status)
  94 {
  95         do_PyThread_exit_prog(status, 1);
  96 }
  97 #endif /* NO_EXIT_PROG */
  98
  99 /*
 100  * Lock support. It has to be implemented using Mutexes, as
 101  * CE doesnt support semaphores.  Therefore we use some hacks to
 102  * simulate the non reentrant requirements of Python locks
 103  */
 104 PyThread_type_lock PyThread_allocate_lock(void)
 105 {
 106     HANDLE aLock;
 107
 108     dprintf(("PyThread_allocate_lock called\n"));
 109     if (!initialized)
 110         PyThread_init_thread();
 111
 112     aLock = CreateEvent(NULL,           /* Security attributes      */
 113                         0,              /* Manual-Reset               */
 114                                                 1,              /* Is initially signalled  */
 115                         NULL);          /* Name of event            */
 116
 117     dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
 118
 119     return (PyThread_type_lock) aLock;
 120 }
 121
 122 void PyThread_free_lock(PyThread_type_lock aLock)
 123 {
 124     dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 125
 126     CloseHandle(aLock);
 127 }
 128
 129 /*
 130  * Return 1 on success if the lock was acquired
 131  *
 132  * and 0 if the lock was not acquired. This means a 0 is returned
 133  * if the lock has already been acquired by this thread!
 134  */
 135 int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 136 {
 137     int success = 1;
 138     DWORD waitResult;
 139
 140     dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
 141
 142 #ifndef DEBUG
 143     waitResult = WaitForSingleObject(aLock, (waitflag ? INFINITE : 0));
 144 #else
 145         /* To aid in debugging, we regularly wake up.  This allows us to
 146         break into the debugger */
 147         while (TRUE) {
 148                 waitResult = WaitForSingleObject(aLock, waitflag ? 3000 : 0);
 149                 if (waitflag==0 || (waitflag && waitResult == WAIT_OBJECT_0))
 150                         break;
 151         }
 152 #endif
 153
 154     if (waitResult != WAIT_OBJECT_0) {
 155                 success = 0;    /* We failed */
 156     }
 157
 158         dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
 159
 160         return success;
 161 }
 162
 163 void PyThread_release_lock(PyThread_type_lock aLock)
 164 {
 165     dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
 166
 167     if (!SetEvent(aLock))
 168         dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
 169 }
 170
 171