release/src/lzma/C/Threads.c

   1 /* Threads.c */
   2
   3 #include "Threads.h"
   4 #include <process.h>
   5
   6 HRes GetError()
   7 {
   8   DWORD res = GetLastError();
   9   return (res) ? (HRes)(res) : SZE_FAIL;
  10 }
  11
  12 HRes BoolToHRes(int v) { return v ? SZ_OK : GetError(); }
  13 HRes BOOLToHRes(BOOL v) { return v ? SZ_OK : GetError(); }
  14
  15 HRes MyCloseHandle(HANDLE *h)
  16 {
  17   if (*h != NULL)
  18     if (!CloseHandle(*h))
  19       return GetError();
  20   *h = NULL;
  21   return SZ_OK;
  22 }
  23
  24 HRes Thread_Create(CThread *thread, THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
  25 {
  26   unsigned threadId; /* Windows Me/98/95: threadId parameter may not be NULL in _beginthreadex/CreateThread functions */
  27   thread->handle =
  28     /* CreateThread(0, 0, startAddress, parameter, 0, &threadId); */
  29     (HANDLE)_beginthreadex(NULL, 0, startAddress, parameter, 0, &threadId);
  30     /* maybe we must use errno here, but probably GetLastError() is also OK. */
  31   return BoolToHRes(thread->handle != 0);
  32 }
  33
  34 HRes WaitObject(HANDLE h)
  35 {
  36   return (HRes)WaitForSingleObject(h, INFINITE);
  37 }
  38
  39 HRes Thread_Wait(CThread *thread)
  40 {
  41   if (thread->handle == NULL)
  42     return 1;
  43   return WaitObject(thread->handle);
  44 }
  45
  46 HRes Thread_Close(CThread *thread)
  47 {
  48   return MyCloseHandle(&thread->handle);
  49 }
  50
  51 HRes Event_Create(CEvent *p, BOOL manualReset, int initialSignaled)
  52 {
  53   p->handle = CreateEvent(NULL, manualReset, (initialSignaled ? TRUE : FALSE), NULL);
  54   return BoolToHRes(p->handle != 0);
  55 }
  56
  57 HRes ManualResetEvent_Create(CManualResetEvent *p, int initialSignaled)
  58   { return Event_Create(p, TRUE, initialSignaled); }
  59 HRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p)
  60   { return ManualResetEvent_Create(p, 0); }
  61
  62 HRes AutoResetEvent_Create(CAutoResetEvent *p, int initialSignaled)
  63   { return Event_Create(p, FALSE, initialSignaled); }
  64 HRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p)
  65   { return AutoResetEvent_Create(p, 0); }
  66
  67 HRes Event_Set(CEvent *p) { return BOOLToHRes(SetEvent(p->handle)); }
  68 HRes Event_Reset(CEvent *p) { return BOOLToHRes(ResetEvent(p->handle)); }
  69 HRes Event_Wait(CEvent *p) { return WaitObject(p->handle); }
  70 HRes Event_Close(CEvent *p) { return MyCloseHandle(&p->handle); }
  71
  72
  73 HRes Semaphore_Create(CSemaphore *p, UInt32 initiallyCount, UInt32 maxCount)
  74 {
  75   p->handle = CreateSemaphore(NULL, (LONG)initiallyCount, (LONG)maxCount, NULL);
  76   return BoolToHRes(p->handle != 0);
  77 }
  78
  79 HRes Semaphore_Release(CSemaphore *p, LONG releaseCount, LONG *previousCount)
  80 {
  81   return BOOLToHRes(ReleaseSemaphore(p->handle, releaseCount, previousCount));
  82 }
  83 HRes Semaphore_ReleaseN(CSemaphore *p, UInt32 releaseCount)
  84 {
  85   return Semaphore_Release(p, (LONG)releaseCount, NULL);
  86 }
  87 HRes Semaphore_Release1(CSemaphore *p)
  88 {
  89   return Semaphore_ReleaseN(p, 1);
  90 }
  91
  92 HRes Semaphore_Wait(CSemaphore *p) { return WaitObject(p->handle); }
  93 HRes Semaphore_Close(CSemaphore *p) { return MyCloseHandle(&p->handle); }
  94
  95 HRes CriticalSection_Init(CCriticalSection *p)
  96 {
  97   /* InitializeCriticalSection can raise only STATUS_NO_MEMORY exception */
  98   __try
  99   {
 100     InitializeCriticalSection(p);
 101     /* InitializeCriticalSectionAndSpinCount(p, 0); */
 102   }
 103   __except (EXCEPTION_EXECUTE_HANDLER) { return SZE_OUTOFMEMORY; }
 104   return SZ_OK;
 105 }
 106