home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / Python2 / Python20_source / Python / thread_cthread.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  3.6 KB  |  191 lines
  1.  
  2. #include <mach/cthreads.h>
  3.  
  4.  
  5. /*
  6.  * Initialization.
  7.  */
  8. static void
  9. PyThread__init_thread(void)
  10. {
  11.     cthread_init();
  12. }
  13.  
  14. /*
  15.  * Thread support.
  16.  */
  17. int
  18. PyThread_start_new_thread(func, void (*func)(void *), void *arg)
  19. {
  20.     int success = 0;    /* init not needed when SOLARIS_THREADS and */
  21.                 /* C_THREADS implemented properly */
  22.  
  23.     dprintf(("PyThread_start_new_thread called\n"));
  24.     if (!initialized)
  25.         PyThread_init_thread();
  26.     /* looks like solaris detaches the thread to never rejoin
  27.      * so well do it here
  28.      */
  29.     cthread_detach(cthread_fork((cthread_fn_t) func, arg));
  30.     return success < 0 ? 0 : 1;
  31. }
  32.  
  33. long
  34. PyThread_get_thread_ident(void)
  35. {
  36.     if (!initialized)
  37.         PyThread_init_thread();
  38.     return (long) cthread_self();
  39. }
  40.  
  41. static void
  42. do_PyThread_exit_thread(int no_cleanup)
  43. {
  44.     dprintf(("PyThread_exit_thread called\n"));
  45.     if (!initialized)
  46.         if (no_cleanup)
  47.             _exit(0);
  48.         else
  49.             exit(0);
  50.     cthread_exit(0);
  51. }
  52.  
  53. void
  54. PyThread_exit_thread(void)
  55. {
  56.     do_PyThread_exit_thread(0);
  57. }
  58.  
  59. void
  60. PyThread__exit_thread(void)
  61. {
  62.     do_PyThread_exit_thread(1);
  63. }
  64.  
  65. #ifndef NO_EXIT_PROG
  66. static
  67. void do_PyThread_exit_prog(int status, int no_cleanup)
  68. {
  69.     dprintf(("PyThread_exit_prog(%d) called\n", status));
  70.     if (!initialized)
  71.         if (no_cleanup)
  72.             _exit(status);
  73.         else
  74.             exit(status);
  75.     if (no_cleanup)
  76.         _exit(status);
  77.     else
  78.         exit(status);
  79. }
  80.  
  81. void
  82. PyThread_exit_prog(int status)
  83. {
  84.     do_PyThread_exit_prog(status, 0);
  85. }
  86.  
  87. void
  88. PyThread__exit_prog(int status)
  89. {
  90.     do_PyThread_exit_prog(status, 1);
  91. }
  92. #endif /* NO_EXIT_PROG */
  93.  
  94. /*
  95.  * Lock support.
  96.  */
  97. PyThread_type_lock
  98. PyThread_allocate_lock(void)
  99. {
  100.     mutex_t lock;
  101.  
  102.     dprintf(("PyThread_allocate_lock called\n"));
  103.     if (!initialized)
  104.         PyThread_init_thread();
  105.  
  106.     lock = mutex_alloc();
  107.     if (mutex_init(lock)) {
  108.         perror("mutex_init");
  109.         free((void *) lock);
  110.         lock = 0;
  111.     }
  112.     dprintf(("PyThread_allocate_lock() -> %p\n", lock));
  113.     return (PyThread_type_lock) lock;
  114. }
  115.  
  116. void
  117. PyThread_free_lock(PyThread_type_lock lock)
  118. {
  119.     dprintf(("PyThread_free_lock(%p) called\n", lock));
  120.     mutex_free(lock);
  121. }
  122.  
  123. int
  124. PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
  125. {
  126.     int success = FALSE;
  127.  
  128.     dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
  129.     if (waitflag) {     /* blocking */
  130.         mutex_lock(lock);
  131.         success = TRUE;
  132.     } else {        /* non blocking */
  133.         success = mutex_try_lock(lock);
  134.     }
  135.     dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
  136.     return success;
  137. }
  138.  
  139. void
  140. PyThread_release_lock(PyThread_type_lock lock)
  141. {
  142.     dprintf(("PyThread_release_lock(%p) called\n", lock));
  143.     mutex_unlock((mutex_t )lock);
  144. }
  145.  
  146. /*
  147.  * Semaphore support.
  148.  *
  149.  * This implementation is ripped directly from the pthreads implementation.
  150.  * Which is to say that it is 100% non-functional at this time.
  151.  *
  152.  * Assuming the page is still up, documentation can be found at:
  153.  *
  154.  * http://www.doc.ic.ac.uk/~mac/manuals/solaris-manual-pages/solaris/usr/man/man2/_lwp_sema_wait.2.html
  155.  *
  156.  * Looking at the man page, it seems that one could easily implement a
  157.  * semaphore using a condition.
  158.  *
  159.  */
  160. PyThread_type_sema
  161. PyThread_allocate_sema(int value)
  162. {
  163.     char *sema = 0;
  164.     dprintf(("PyThread_allocate_sema called\n"));
  165.     if (!initialized)
  166.         PyThread_init_thread();
  167.  
  168.     dprintf(("PyThread_allocate_sema() -> %p\n", sema));
  169.     return (PyThread_type_sema) sema;
  170. }
  171.  
  172. void
  173. PyThread_free_sema(PyThread_type_sema sema)
  174. {
  175.     dprintf(("PyThread_free_sema(%p) called\n", sema));
  176. }
  177.  
  178. int
  179. PyThread_down_sema(PyThread_type_sema sema, int waitflag)
  180. {
  181.     dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
  182.     dprintf(("PyThread_down_sema(%p) return\n", sema));
  183.     return -1;
  184. }
  185.  
  186. void
  187. PyThread_up_sema(PyThread_type_sema sema)
  188. {
  189.     dprintf(("PyThread_up_sema(%p)\n", sema));
  190. }
  191.