home *** CD-ROM | disk | FTP | other *** search
/ Download Now 8 / Download Now V8.iso / Program / InternetTools / ApacheWebServer1.3.6 / apache_1_3_6_win32.exe / _SETUP.1 / multithread.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-13  |  3.9 KB  |  259 lines
  1.  
  2. #include "ap_config.h"
  3. #include "multithread.h"
  4.  
  5. #ifdef WIN32
  6. #include <process.h>
  7. #include <assert.h>
  8.  
  9.  
  10. static int
  11. map_rv(int rv)
  12. {
  13.     switch(rv)
  14.     {
  15.     case WAIT_OBJECT_0:
  16.     case WAIT_ABANDONED:
  17.         return(MULTI_OK);
  18.     case WAIT_TIMEOUT:
  19.         return(MULTI_TIMEOUT);
  20.     case WAIT_FAILED:
  21.         return(MULTI_ERR);
  22.     default:
  23.         assert(0);
  24.     }
  25.  
  26.     assert(0);
  27.     return(0);
  28. }
  29.  
  30.  
  31. thread *
  32. create_thread(void (thread_fn)(void *), void *thread_arg)
  33. {
  34.     int id;
  35.     int rv;
  36.     
  37.     rv = _beginthreadex(NULL, 0, (LPTHREAD_START_ROUTINE)thread_fn,
  38.             thread_arg, 0, &id);
  39.  
  40.     return((thread *)rv);
  41. }
  42.  
  43.  
  44. int
  45. kill_thread(thread *thread_id)
  46. {
  47.     return(TerminateThread(thread_id, 1));
  48. }
  49.  
  50.  
  51. int
  52. await_thread(thread *thread_id, int sec_to_wait)
  53. {
  54.     int rv;
  55.     
  56.     rv = WaitForSingleObject(thread_id, sec_to_wait*1000);
  57.     
  58.     return(map_rv(rv));
  59. }
  60.  
  61. void
  62. exit_thread(int status)
  63. {
  64.     _endthreadex(status);
  65. }
  66.  
  67. void
  68. free_thread(thread *thread_id)
  69. {
  70.     CloseHandle(thread_id);
  71. }
  72.  
  73.  
  74.  
  75. API_EXPORT(mutex *) ap_create_mutex(char *name)
  76. {
  77.     return(CreateMutex(NULL, FALSE, name));
  78. }
  79.  
  80. API_EXPORT(mutex *) ap_open_mutex(char *name)
  81. {
  82.     return(OpenMutex(MUTEX_ALL_ACCESS, FALSE, name));
  83. }
  84.  
  85.  
  86. API_EXPORT(int) ap_acquire_mutex(mutex *mutex_id)
  87. {
  88.     int rv;
  89.     
  90.     rv = WaitForSingleObject(mutex_id, INFINITE);
  91.     
  92.     return(map_rv(rv));
  93. }
  94.  
  95. API_EXPORT(int) ap_release_mutex(mutex *mutex_id)
  96. {
  97.     return(ReleaseMutex(mutex_id));
  98. }
  99.  
  100. API_EXPORT(void) ap_destroy_mutex(mutex *mutex_id)
  101. {
  102.     CloseHandle(mutex_id);
  103. }
  104.  
  105.  
  106. semaphore *
  107. create_semaphore(int initial)
  108. {
  109.     return(CreateSemaphore(NULL, initial, 1000000, NULL));
  110. }
  111.  
  112. int acquire_semaphore(semaphore *semaphore_id)
  113. {
  114.     int rv;
  115.     
  116.     rv = WaitForSingleObject(semaphore_id, INFINITE);
  117.     
  118.     return(map_rv(rv));
  119. }
  120.  
  121. int release_semaphore(semaphore *semaphore_id)
  122. {
  123.     return(ReleaseSemaphore(semaphore_id, 1, NULL));
  124. }
  125.  
  126. void destroy_semaphore(semaphore *semaphore_id)
  127. {
  128.     CloseHandle(semaphore_id);
  129. }
  130.  
  131.  
  132. event *
  133. create_event(int manual, int initial, char *name)
  134. {
  135.     return(CreateEvent(NULL, manual, initial, name));
  136. }
  137.  
  138. event *
  139. open_event(char *name)
  140. {
  141.     return(OpenEvent(EVENT_ALL_ACCESS, FALSE, name));
  142. }
  143.  
  144.  
  145. int acquire_event(event *event_id)
  146. {
  147.     int rv;
  148.     
  149.     rv = WaitForSingleObject(event_id, INFINITE);
  150.     
  151.     return(map_rv(rv));
  152. }
  153.  
  154. int set_event(event *event_id)
  155. {
  156.     return(SetEvent(event_id));
  157. }
  158.  
  159. int reset_event(event *event_id)
  160. {
  161.     return(ResetEvent(event_id));
  162. }
  163.  
  164.  
  165. void destroy_event(event *event_id)
  166. {
  167.     CloseHandle(event_id);
  168. }
  169.  
  170. #else
  171.  
  172.  
  173. thread *create_thread(void (thread_fn)(void *thread_arg),
  174.     void *thread_arg)
  175. {
  176.     return(NULL);
  177. }
  178.  
  179. int kill_thread(thread *thread_id)
  180. {
  181.     return(0);
  182. }
  183.  
  184. int await_thread(thread *thread_id, int sec_to_wait)
  185. {
  186.     return(0);
  187. }
  188.  
  189. void exit_thread(int status)
  190. {}
  191.  
  192. void free_thread(thread *thread_id)
  193. {}
  194.  
  195.  
  196. mutex *ap_create_mutex(char *name)
  197. {
  198.     return(NULL);
  199. }
  200.  
  201. mutex *ap_open_mutex(char *name)
  202. {
  203.     return(NULL);
  204. }
  205.  
  206. int ap_acquire_mutex(mutex *mutex_id)
  207. {
  208.     return(0);
  209. }
  210. int ap_release_mutex(mutex *mutex_id)
  211. {
  212.     return(0);
  213. }
  214. void ap_destroy_mutex(mutex *mutex_id)
  215. {}
  216.  
  217.  
  218. semaphore *create_semaphore(int initial)
  219. {
  220.     return(NULL);
  221. }
  222. int acquire_semaphore(semaphore *semaphore_id)
  223. {
  224.     return(0);
  225. }
  226. int release_semaphore(semaphore *semaphore_id)
  227. {
  228.     return(0);
  229. }
  230. void destroy_semaphore(semaphore *semaphore_id)
  231. {}
  232.  
  233. event *create_event(int manual, int initial, char *name)
  234. {
  235.     return(NULL);
  236. }
  237. event *open_event(char *name)
  238. {
  239.     return(NULL);
  240. }
  241. int acquire_event(event *event_id)
  242. {
  243.     return(0);
  244. }
  245. int set_event(event *event_id)
  246. {
  247.     return(0);
  248. }
  249. int reset_event(event *event_id)
  250. {
  251.     return(0);
  252. }
  253. void destroy_event(event *event_id)
  254. {}
  255.  
  256.  
  257. #endif /* WIN32 */
  258.  
  259.