home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / Python2 / Python20_source / Python / thread_wince.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  4.0 KB  |  172 lines
  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. int PyThread_start_new_thread(void (*func)(void *), void *arg)
  26. {
  27.     long rv;
  28.     int success = 0;
  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 = 1;
  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 == 1 ? 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==1 && 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.  
  172.