react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/System.cpp

@@ -2,204 +2,59 @@
 
 #include "StdAfx.h"
 
-#ifndef _WIN32
-#include <unistd.h>
-#include <limits.h>
-#if defined(__APPLE__) || defined(__DragonFly__) || \
-    defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-#include <sys/sysctl.h>
-#else
-#include <sys/sysinfo.h>
-#endif
-#endif
+#include "../Common/MyWindows.h"
 
 #include "../Common/Defs.h"
-// #include "../Common/MyWindows.h"
-
-// #include "../../C/CpuArch.h"
 
 #include "System.h"
 
 namespace NWindows {
 namespace NSystem {
 
-#ifdef _WIN32
-
-/*
-note: returned value in 32-bit version can be limited by value 32.
-      while 64-bit version returns full value.
-GetMaximumProcessorCount(groupNumber) can return higher value than
-GetActiveProcessorCount(groupNumber) in some cases, because CPUs can be added.
-*/
-// typedef DWORD (WINAPI *Func_GetMaximumProcessorCount)(WORD GroupNumber);
-typedef DWORD (WINAPI *Func_GetActiveProcessorCount)(WORD GroupNumber);
-typedef WORD (WINAPI *Func_GetActiveProcessorGroupCount)(VOID);
-/*
-#if 0 && defined(ALL_PROCESSOR_GROUPS)
-#define MY_ALL_PROCESSOR_GROUPS   ALL_PROCESSOR_GROUPS
-#else
-#define MY_ALL_PROCESSOR_GROUPS   0xffff
-#endif
-*/
-
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
-
-bool CCpuGroups::Load()
-{
-  NumThreadsTotal = 0;
-  GroupSizes.Clear();
-  const HMODULE hmodule = ::GetModuleHandleA("kernel32.dll");
-  // Is_Win11_Groups = GetProcAddress(hmodule, "SetThreadSelectedCpuSetMasks") != NULL;
-  const
-      Func_GetActiveProcessorGroupCount
-        fn_GetActiveProcessorGroupCount = Z7_GET_PROC_ADDRESS(
-      Func_GetActiveProcessorGroupCount, hmodule,
-          "GetActiveProcessorGroupCount");
-  const
-      Func_GetActiveProcessorCount
-        fn_GetActiveProcessorCount = Z7_GET_PROC_ADDRESS(
-      Func_GetActiveProcessorCount, hmodule,
-          "GetActiveProcessorCount");
-  if (!fn_GetActiveProcessorGroupCount ||
-      !fn_GetActiveProcessorCount)
-    return false;
-
-  const unsigned numGroups = fn_GetActiveProcessorGroupCount();
-  if (numGroups == 0)
-    return false;
-  UInt32 sum = 0;
-  for (unsigned i = 0; i < numGroups; i++)
-  {
-    const UInt32 num = fn_GetActiveProcessorCount((WORD)i);
-    /*
-    if (num == 0)
-    {
-      // it means error
-      // but is it possible that some group is empty by some reason?
-      // GroupSizes.Clear();
-      // return false;
-    }
-    */
-    sum += num;
-    GroupSizes.Add(num);
-  }
-  NumThreadsTotal = sum;
-  // NumThreadsTotal = fn_GetActiveProcessorCount(MY_ALL_PROCESSOR_GROUPS);
-  return true;
-}
-
 UInt32 CountAffinity(DWORD_PTR mask)
 {
   UInt32 num = 0;
   for (unsigned i = 0; i < sizeof(mask) * 8; i++)
-  {
-    num += (UInt32)(mask & 1);
-    mask >>= 1;
-  }
+    num += (UInt32)((mask >> i) & 1);
   return num;
 }
 
+#ifdef _WIN32
+
 BOOL CProcessAffinity::Get()
 {
-  IsGroupMode = false;
-  Groups.Load();
-  // SetThreadAffinityMask(GetCurrentThread(), 1);
-  // SetProcessAffinityMask(GetCurrentProcess(), 1);
-  BOOL res = GetProcessAffinityMask(GetCurrentProcess(),
-      &processAffinityMask, &systemAffinityMask);
-  /* DOCs: On a system with more than 64 processors, if the threads
-     of the calling process  are in a single processor group, the
-     function sets the variables pointed to by lpProcessAffinityMask
-     and lpSystemAffinityMask to the process affinity mask and the
-     processor mask of active logical processors for that group.
-     If the calling process contains threads in multiple groups,
-     the function returns zero for both affinity masks
-
-     note: tested in Win10: GetProcessAffinityMask() doesn't return 0
-           in (processAffinityMask) and (systemAffinityMask) masks.
-     We need to test it in Win11: how to get mask==0 from GetProcessAffinityMask()?
-  */
-  if (!res)
-  {
-    processAffinityMask = 0;
-    systemAffinityMask = 0;
-  }
-  if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
-    if (// !res ||
-        processAffinityMask == 0 || // to support case described in DOCs and for (!res) case
-        processAffinityMask == systemAffinityMask) // for default nonchanged affinity
-    {
-      // we set IsGroupMode only if processAffinity is default (not changed).
-      res = TRUE;
-      IsGroupMode = true;
-    }
-  return res;
+  #ifndef UNDER_CE
+  return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
+  #else
+  return FALSE;
+  #endif
 }
 
 
-UInt32 CProcessAffinity::Load_and_GetNumberOfThreads()
-{
-  if (Get())
-  {
-    const UInt32 numProcessors = GetNumProcessThreads();
-    if (numProcessors)
-      return numProcessors;
-  }
-  SYSTEM_INFO systemInfo;
-  GetSystemInfo(&systemInfo);
-  // the number of logical processors in the current group
-  return systemInfo.dwNumberOfProcessors;
-}
-
 UInt32 GetNumberOfProcessors()
 {
   // We need to know how many threads we can use.
   // By default the process is assigned to one group.
-  CProcessAffinity pa;
-  return pa.Load_and_GetNumberOfThreads();
-}
+  // So we get the number of logical processors (threads)
+  // assigned to current process in the current group.
+  // Group size can be smaller than total number logical processors, for exammple, 2x36
 
-#else
+  CProcessAffinity pa;
 
+  if (pa.Get() && pa.processAffinityMask != 0)
+    return pa.GetNumProcessThreads();
 
-BOOL CProcessAffinity::Get()
-{
-  numSysThreads = GetNumberOfProcessors();
-
-  /*
-  numSysThreads = 8;
-  for (unsigned i = 0; i < numSysThreads; i++)
-    CpuSet_Set(&cpu_set, i);
-  return TRUE;
-  */
-  
-  #ifdef Z7_AFFINITY_SUPPORTED
-  
-  // numSysThreads = sysconf(_SC_NPROCESSORS_ONLN); // The number of processors currently online
-  if (sched_getaffinity(0, sizeof(cpu_set), &cpu_set) != 0)
-    return FALSE;
-  return TRUE;
-  
-  #else
-  
-  // cpu_set = ((CCpuSet)1 << (numSysThreads)) - 1;
-  return TRUE;
-  // errno = ENOSYS;
-  // return FALSE;
-  
-  #endif
+  SYSTEM_INFO systemInfo;
+  GetSystemInfo(&systemInfo);
+  // the number of logical processors in the current group
+  return (UInt32)systemInfo.dwNumberOfProcessors;
 }
 
+#else
+
 UInt32 GetNumberOfProcessors()
 {
-  #ifndef Z7_ST
-  long n = sysconf(_SC_NPROCESSORS_CONF);  // The number of processors configured
-  if (n < 1)
-    n = 1;
-  return (UInt32)n;
-  #else
   return 1;
-  #endif
 }
 
 #endif
@@ -209,10 +64,9 @@ UInt32 GetNumberOfProcessors()
 
 #ifndef UNDER_CE
 
-#if !defined(_WIN64) && \
-  (defined(__MINGW32_VERSION) || defined(Z7_OLD_WIN_SDK))
+#if !defined(_WIN64) && defined(__GNUC__)
 
-typedef struct {
+typedef struct _MY_MEMORYSTATUSEX {
   DWORD dwLength;
   DWORD dwMemoryLoad;
   DWORDLONG ullTotalPhys;
@@ -231,15 +85,19 @@ typedef struct {
 
 #endif
 
-typedef BOOL (WINAPI *Func_GlobalMemoryStatusEx)(MY_LPMEMORYSTATUSEX lpBuffer);
+typedef BOOL (WINAPI *GlobalMemoryStatusExP)(MY_LPMEMORYSTATUSEX lpBuffer);
 
-#endif // !UNDER_CE
+#endif
 
-  
-bool GetRamSize(size_t &size)
+#endif
+
+
+bool GetRamSize(UInt64 &size)
 {
-  size = (size_t)sizeof(size_t) << 29;
+  size = (UInt64)(sizeof(size_t)) << 29;
 
+  #ifdef _WIN32
+  
   #ifndef UNDER_CE
     MY_MEMORYSTATUSEX stat;
     stat.dwLength = sizeof(stat);
@@ -255,29 +113,15 @@ bool GetRamSize(size_t &size)
   #else
     
     #ifndef UNDER_CE
-      const
-      Func_GlobalMemoryStatusEx fn = Z7_GET_PROC_ADDRESS(
-      Func_GlobalMemoryStatusEx, ::GetModuleHandleA("kernel32.dll"),
-          "GlobalMemoryStatusEx");
-      if (fn && fn(&stat))
+      GlobalMemoryStatusExP globalMemoryStatusEx = (GlobalMemoryStatusExP)
+          ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GlobalMemoryStatusEx");
+      if (globalMemoryStatusEx && globalMemoryStatusEx(&stat))
       {
-        // (MY_MEMORYSTATUSEX::ullTotalVirtual) < 4 GiB in 32-bit mode
-        size_t size2 = (size_t)0 - 1;
-        if (size2 > stat.ullTotalPhys)
-            size2 = (size_t)stat.ullTotalPhys;
-        if (size2 > stat.ullTotalVirtual)
-            size2 = (size_t)stat.ullTotalVirtual;
-        size = size2;
+        size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
         return true;
       }
     #endif
   
-    // On computers with more than 4 GB of memory:
-    //   new docs  : GlobalMemoryStatus can report (-1) value to indicate an overflow.
-    //   some old docs : GlobalMemoryStatus can report (modulo 4 GiB) value.
-    //                   (for example, if 5 GB total memory, it could report 1 GB).
-    // We don't want to get (modulo 4 GiB) value.
-    // So we use GlobalMemoryStatusEx() instead.
     {
       MEMORYSTATUS stat2;
       stat2.dwLength = sizeof(stat2);
@@ -285,137 +129,14 @@ bool GetRamSize(size_t &size)
       size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
       return true;
     }
-  #endif
-}
   
-#else
-
-// POSIX
-// #include <stdio.h>
-
-bool GetRamSize(size_t &size)
-{
-  UInt64 size64;
-  size = (size_t)sizeof(size_t) << 29;
-  size64 = size;
-
-#if defined(__APPLE__) || defined(__DragonFly__) || \
-    defined(BSD) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
-
-    uint64_t val = 0;
-    int mib[2];
-    mib[0] = CTL_HW;
-
-    #ifdef HW_MEMSIZE
-      mib[1] = HW_MEMSIZE;
-      // printf("\n sysctl HW_MEMSIZE");
-    #elif defined(HW_PHYSMEM64)
-      mib[1] = HW_PHYSMEM64;
-      // printf("\n sysctl HW_PHYSMEM64");
-    #else
-      mib[1] = HW_PHYSMEM;
-      // printf("\n sysctl HW_PHYSMEM");
-    #endif
-
-    size_t size_sys = sizeof(val);
-    int res = sysctl(mib, 2, &val, &size_sys, NULL, 0);
-    // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val, (int)size_sys, errno);
-    // we use strict check (size_sys == sizeof(val)) for returned value
-    // because big-endian encoding is possible:
-    if (res == 0 && size_sys == sizeof(val) && val)
-      size64 = val;
-    else
-    {
-      uint32_t val32 = 0;
-      size_sys = sizeof(val32);
-      res = sysctl(mib, 2, &val32, &size_sys, NULL, 0);
-      // printf("\n sysctl res=%d val=%llx size_sys = %d, %d\n", res, (long long int)val32, (int)size_sys, errno);
-      if (res == 0 && size_sys == sizeof(val32) && val32)
-        size64 = val32;
-    }
+  #endif
 
-  #elif defined(_AIX)
-    #if defined(_SC_AIX_REALMEM) // AIX
-      size64 = (UInt64)sysconf(_SC_AIX_REALMEM) * 1024;
-    #endif
-  #elif 0 || defined(__sun)
-    #if defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
-    // FreeBSD, Linux, OpenBSD, and Solaris.
-    {
-      const long phys_pages = sysconf(_SC_PHYS_PAGES);
-      const long page_size = sysconf(_SC_PAGESIZE);
-      // #pragma message("GetRamSize : sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE)")
-      // printf("\n_SC_PHYS_PAGES (hex) = %lx", (unsigned long)phys_pages);
-      // printf("\n_SC_PAGESIZE = %lu\n", (unsigned long)page_size);
-      if (phys_pages != -1 && page_size != -1)
-        size64 = (UInt64)(Int64)phys_pages * (UInt64)(Int64)page_size;
-    }
-    #endif
-  #elif defined(__gnu_hurd__)
-  // fixme
-  #elif defined(__FreeBSD_kernel__) && defined(__GLIBC__)
-  // GNU/kFreeBSD Debian
-  // fixme
   #else
 
-  struct sysinfo info;
-  if (::sysinfo(&info) != 0)
-    return false;
-  size64 = (UInt64)info.mem_unit * info.totalram;
-  /*
-  printf("\n mem_unit  = %lld", (UInt64)info.mem_unit);
-  printf("\n totalram  = %lld", (UInt64)info.totalram);
-  printf("\n freeram   = %lld", (UInt64)info.freeram);
-  */
+  return false;
 
   #endif
-
-  size = (size_t)1 << (sizeof(size_t) * 8 - 1);
-  if (size > size64)
-      size = (size_t)size64;
-  return true;
-}
-
-#endif
-
-
-unsigned long Get_File_OPEN_MAX()
-{
- #ifdef _WIN32
-  return (1 << 24) - (1 << 16); // ~16M handles
- #else
-  // some linux versions have default open file limit for user process of 1024 files.
-  long n = sysconf(_SC_OPEN_MAX);
-  // n = -1; // for debug
-  // n = 9; // for debug
-  if (n < 1)
-  {
-    // n = OPEN_MAX;  // ???
-    // n = FOPEN_MAX; // = 16 : <stdio.h>
-   #ifdef _POSIX_OPEN_MAX
-    n = _POSIX_OPEN_MAX; // = 20 : <limits.h>
-   #else
-    n = 30; // our limit
-   #endif
-  }
-  return (unsigned long)n;
- #endif
-}
-
-unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks()
-{
-  unsigned long numFiles_OPEN_MAX = NSystem::Get_File_OPEN_MAX();
-  const unsigned delta = 10; // the reserve for another internal needs of process
-  if (numFiles_OPEN_MAX > delta)
-    numFiles_OPEN_MAX -= delta;
-  else
-    numFiles_OPEN_MAX = 1;
-  numFiles_OPEN_MAX /= 3; // we suppose that we have up to 3 tasks in total for multiple file processing
-  numFiles_OPEN_MAX = MyMax(numFiles_OPEN_MAX, (unsigned long)3);
-  unsigned n = (unsigned)(int)-1;
-  if (n > numFiles_OPEN_MAX)
-    n = (unsigned)numFiles_OPEN_MAX;
-  return n;
 }
 
 }}

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/System.h

@@ -1,50 +1,13 @@
 // Windows/System.h
 
-#ifndef ZIP7_INC_WINDOWS_SYSTEM_H
-#define ZIP7_INC_WINDOWS_SYSTEM_H
-
-#ifndef _WIN32
-// #include <sched.h>
-#include "../../C/Threads.h"
-#endif
+#ifndef __WINDOWS_SYSTEM_H
+#define __WINDOWS_SYSTEM_H
 
 #include "../Common/MyTypes.h"
-#include "../Common/MyVector.h"
-#include "../Common/MyWindows.h"
 
 namespace NWindows {
 namespace NSystem {
 
-#ifdef _WIN32
-
-struct CCpuGroups
-{
-  CRecordVector<UInt32> GroupSizes;
-  UInt32 NumThreadsTotal; // sum of threads in all groups
-  // bool Is_Win11_Groups; // useless
-  
-  void Get_GroupSize_Min_Max(UInt32 &minSize, UInt32 &maxSize) const
-  {
-    unsigned num = GroupSizes.Size();
-    UInt32 minSize2 = 0, maxSize2 = 0;
-    if (num)
-    {
-      minSize2 = (UInt32)0 - 1;
-      do
-      {
-        const UInt32 v = GroupSizes[--num];
-        if (minSize2 > v) minSize2 = v;
-        if (maxSize2 < v) maxSize2 = v;
-      }
-      while (num);
-    }
-    minSize = minSize2;
-    maxSize = maxSize2;
-  }
-  bool Load();
-  CCpuGroups(): NumThreadsTotal(0) {}
-};
-
 UInt32 CountAffinity(DWORD_PTR mask);
 
 struct CProcessAffinity
@@ -54,135 +17,23 @@ struct CProcessAffinity
   DWORD_PTR processAffinityMask;
   DWORD_PTR systemAffinityMask;
 
-  CCpuGroups Groups;
-  bool IsGroupMode;
-    /*
-      IsGroupMode == true, if
-          Groups.GroupSizes.Size() > 1) && { dafalt affinity was not changed }
-      IsGroupMode == false, if single group or affinity was changed
-    */
-  
-  UInt32 Load_and_GetNumberOfThreads();
-
   void InitST()
   {
     // numProcessThreads = 1;
     // numSysThreads = 1;
     processAffinityMask = 1;
     systemAffinityMask = 1;
-    IsGroupMode = false;
-    // Groups.NumThreadsTotal = 0;
-    // Groups.Is_Win11_Groups = false;
   }
 
-/*
-  void CpuZero()
-  {
-    processAffinityMask = 0;
-  }
-
-  void CpuSet(unsigned cpuIndex)
-  {
-    processAffinityMask |= ((DWORD_PTR)1 << cpuIndex);
-  }
-*/
-
-  UInt32 GetNumProcessThreads() const
-  {
-    if (IsGroupMode)
-      return Groups.NumThreadsTotal;
-    // IsGroupMode == false
-    // so we don't want to use groups
-    // we return number of threads in default primary group:
-    return CountAffinity(processAffinityMask);
-  }
-  UInt32 GetNumSystemThreads() const
-  {
-    if (Groups.GroupSizes.Size() > 1 && Groups.NumThreadsTotal)
-      return Groups.NumThreadsTotal;
-    return CountAffinity(systemAffinityMask);
-  }
+  UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
+  UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
 
   BOOL Get();
-
-  BOOL SetProcAffinity() const
-  {
-    return SetProcessAffinityMask(GetCurrentProcess(), processAffinityMask);
-  }
 };
 
-
-#else // WIN32
-
-struct CProcessAffinity
-{
-  UInt32 numSysThreads;
-
-  UInt32 GetNumSystemThreads() const { return (UInt32)numSysThreads; }
-  BOOL Get();
-
-  #ifdef Z7_AFFINITY_SUPPORTED
-
-  CCpuSet cpu_set;
-
-  void InitST()
-  {
-    numSysThreads = 1;
-    CpuSet_Zero(&cpu_set);
-    CpuSet_Set(&cpu_set, 0);
-  }
-
-  UInt32 GetNumProcessThreads() const { return (UInt32)CPU_COUNT(&cpu_set); }
-  void CpuZero()              { CpuSet_Zero(&cpu_set); }
-  void CpuSet(unsigned cpuIndex)   { CpuSet_Set(&cpu_set, cpuIndex); }
-  int IsCpuSet(unsigned cpuIndex) const { return CpuSet_IsSet(&cpu_set, cpuIndex); }
-  // void CpuClr(int cpuIndex) { CPU_CLR(cpuIndex, &cpu_set); }
-
-  BOOL SetProcAffinity() const
-  {
-    return sched_setaffinity(0, sizeof(cpu_set), &cpu_set) == 0;
-  }
-
-  #else // Z7_AFFINITY_SUPPORTED
-
-  void InitST()
-  {
-    numSysThreads = 1;
-  }
-  
-  UInt32 GetNumProcessThreads() const
-  {
-    return numSysThreads;
-    /*
-    UInt32 num = 0;
-    for (unsigned i = 0; i < sizeof(cpu_set) * 8; i++)
-      num += (UInt32)((cpu_set >> i) & 1);
-    return num;
-    */
-  }
-  
-  void CpuZero() { }
-  void CpuSet(unsigned /* cpuIndex */) { /* UNUSED_VAR(cpuIndex) */ }
-  int IsCpuSet(unsigned cpuIndex) const { return (cpuIndex < numSysThreads) ? 1 : 0; }
-
-  BOOL SetProcAffinity() const
-  {
-    errno = ENOSYS;
-    return FALSE;
-  }
-  
-  #endif // Z7_AFFINITY_SUPPORTED
-};
-
-#endif // _WIN32
-
-
 UInt32 GetNumberOfProcessors();
 
-bool GetRamSize(size_t &size); // returns false, if unknown ram size
-
-unsigned long Get_File_OPEN_MAX();
-unsigned Get_File_OPEN_MAX_Reduced_for_3_tasks();
+bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
 
 }}
 

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/Thread.h

@@ -1,7 +1,7 @@
 // Windows/Thread.h
 
-#ifndef ZIP7_INC_WINDOWS_THREAD_H
-#define ZIP7_INC_WINDOWS_THREAD_H
+#ifndef __WINDOWS_THREAD_H
+#define __WINDOWS_THREAD_H
 
 #include "../../C/Threads.h"
 
@@ -9,27 +9,19 @@
 
 namespace NWindows {
 
-class CThread  MY_UNCOPYABLE
+class CThread
 {
   ::CThread thread;
 public:
-  CThread() { Thread_CONSTRUCT(&thread) }
+  CThread() { Thread_Construct(&thread); }
   ~CThread() { Close(); }
   bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
   WRes Close()  { return Thread_Close(&thread); }
-  // WRes Wait() { return Thread_Wait(&thread); }
-  WRes Wait_Close() { return Thread_Wait_Close(&thread); }
-
-  WRes Create(THREAD_FUNC_TYPE startAddress, LPVOID param)
-    { return Thread_Create(&thread, startAddress, param); }
-  WRes Create_With_Affinity(THREAD_FUNC_TYPE startAddress, LPVOID param, CAffinityMask affinity)
-    { return Thread_Create_With_Affinity(&thread, startAddress, param, affinity); }
-  WRes Create_With_CpuSet(THREAD_FUNC_TYPE startAddress, LPVOID param, const CCpuSet *cpuSet)
-    { return Thread_Create_With_CpuSet(&thread, startAddress, param, cpuSet); }
- 
-#ifdef _WIN32
-  WRes Create_With_Group(THREAD_FUNC_TYPE startAddress, LPVOID param, unsigned group, CAffinityMask affinity = 0)
-    { return Thread_Create_With_Group(&thread, startAddress, param, group, affinity); }
+  WRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
+    { return Thread_Create(&thread, startAddress, parameter); }
+  WRes Wait() { return Thread_Wait(&thread); }
+  
+  #ifdef _WIN32
   operator HANDLE() { return thread; }
   void Attach(HANDLE handle) { thread = handle; }
   HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
@@ -38,7 +30,7 @@ public:
   bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
   int GetPriority() { return ::GetThreadPriority(thread); }
   bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
-#endif
+  #endif
 };
 
 }