4.46 beta

CPP/Windows/Defs.h

@@ -6,8 +6,10 @@
 inline bool BOOLToBool(BOOL value)
   { return (value != FALSE); }
 
+#ifdef _WIN32
 inline bool LRESULTToBool(LRESULT value)
   { return (value != FALSE); }
+#endif
 
 inline BOOL BoolToBOOL(bool value)
   { return (value ? TRUE: FALSE); }

CPP/Windows/FileIO.cpp

@@ -180,15 +180,21 @@ bool CFileBase::GetFileInformation(CByHandleFileInfo &fileInfo) const
 bool CInFile::Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
   { return Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes); }
 
+bool CInFile::OpenShared(LPCTSTR fileName, bool shareForWrite)
+{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
+
 bool CInFile::Open(LPCTSTR fileName)
-  { return Open(fileName, FILE_SHARE_READ, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
+  { return OpenShared(fileName, false); }
 
 #ifndef _UNICODE
 bool CInFile::Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
   { return Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes); }
 
+bool CInFile::OpenShared(LPCWSTR fileName, bool shareForWrite)
+{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
+
 bool CInFile::Open(LPCWSTR fileName)
-  { return Open(fileName, FILE_SHARE_READ, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
+  { return OpenShared(fileName, false); }
 #endif
 
 // ReadFile and WriteFile functions in Windows have BUG:
@@ -196,7 +202,11 @@ bool CInFile::Open(LPCWSTR fileName)
 // from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES 
 // (Insufficient system resources exist to complete the requested service).
 
-static UInt32 kChunkSizeMax = (1 << 24);
+// Probably in some version of Windows there are problems with other sizes: 
+// for 32 MB (maybe also for 16 MB). 
+// And message can be "Network connection was lost"
+
+static UInt32 kChunkSizeMax = (1 << 22);
 
 bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize)
 {

CPP/Windows/FileIO.h

@@ -53,9 +53,11 @@ class CInFile: public CFileBase
 {
 public:
   bool Open(LPCTSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
+  bool OpenShared(LPCTSTR fileName, bool shareForWrite);
   bool Open(LPCTSTR fileName);
   #ifndef _UNICODE
   bool Open(LPCWSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
+  bool OpenShared(LPCWSTR fileName, bool shareForWrite);
   bool Open(LPCWSTR fileName);
   #endif
   bool ReadPart(void *data, UInt32 size, UInt32 &processedSize);

CPP/Windows/ResourceString.cpp

@@ -51,7 +51,7 @@ UString MyLoadStringW(HINSTANCE hInstance, UINT resourceID)
     s.ReleaseBuffer();
     return s;
   }
-  return GetUnicodeString(MyLoadString(resourceID));
+  return GetUnicodeString(MyLoadString(hInstance, resourceID));
 }
 
 UString MyLoadStringW(UINT resourceID)

CPP/Windows/Synchronization.cpp

@@ -7,11 +7,4 @@
 namespace NWindows {
 namespace NSynchronization {
 
-CEvent::CEvent(bool manualReset, bool initiallyOwn, LPCTSTR name,
-    LPSECURITY_ATTRIBUTES securityAttributes)
-{
-  if (!Create(manualReset, initiallyOwn, name, securityAttributes))
-    throw "CreateEvent error";
-}
-
 }}

CPP/Windows/Synchronization.h

@@ -4,81 +4,120 @@
 #define __WINDOWS_SYNCHRONIZATION_H
 
 #include "Defs.h"
+
+extern "C" 
+{ 
+#include "../../C/Threads.h"
+}
+
+#ifdef _WIN32
 #include "Handle.h"
+#endif
 
 namespace NWindows {
 namespace NSynchronization {
 
+class CBaseEvent
+{
+protected:
+  ::CEvent _object;
+public:
+  bool IsCreated() { return Event_IsCreated(&_object) != 0; }
+  operator HANDLE() { return _object.handle; }
+  CBaseEvent() { Event_Construct(&_object); }
+  ~CBaseEvent() { Close(); }
+  HRes Close() { return Event_Close(&_object); }
+  #ifdef _WIN32
+  HRes Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL,
+      LPSECURITY_ATTRIBUTES securityAttributes = NULL)
+  {
+    _object.handle = ::CreateEvent(securityAttributes, BoolToBOOL(manualReset),
+        BoolToBOOL(initiallyOwn), name);
+    if (_object.handle != 0)
+      return 0;
+    return ::GetLastError();
+  }
+  HRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
+  {
+    _object.handle = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
+    if (_object.handle != 0)
+      return 0;
+    return ::GetLastError();
+  }
+  #endif
+
+  HRes Set() { return Event_Set(&_object); }
+  // bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
+  HRes Reset() { return Event_Reset(&_object); }
+  HRes Lock() { return Event_Wait(&_object); }
+};
+
+class CManualResetEvent: public CBaseEvent
+{
+public:
+  HRes Create(bool initiallyOwn = false)
+  {
+    return ManualResetEvent_Create(&_object, initiallyOwn ? 1: 0);
+  }
+  HRes CreateIfNotCreated()
+  {
+    if (IsCreated())
+      return 0;
+    return ManualResetEvent_CreateNotSignaled(&_object);
+  }
+  #ifdef _WIN32
+  HRes CreateWithName(bool initiallyOwn, LPCTSTR name)
+  {
+    return CBaseEvent::Create(true, initiallyOwn, name);
+  }
+  #endif
+};
+
+class CAutoResetEvent: public CBaseEvent
+{
+public:
+  HRes Create()
+  {
+    return AutoResetEvent_CreateNotSignaled(&_object);
+  }
+  HRes CreateIfNotCreated()
+  {
+    if (IsCreated())
+      return 0;
+    return AutoResetEvent_CreateNotSignaled(&_object);
+  }
+};
+
+#ifdef _WIN32
 class CObject: public CHandle
 {
 public:
-  bool Lock(DWORD timeoutInterval = INFINITE)
-    { return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0); }
+  HRes Lock(DWORD timeoutInterval = INFINITE)
+    { return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0 ? 0 : ::GetLastError()); }
 };
-
-class CBaseEvent: public CObject
-{
-public:
-  bool Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL,
-      LPSECURITY_ATTRIBUTES securityAttributes = NULL)
-  {
-    _handle = ::CreateEvent(securityAttributes, BoolToBOOL(manualReset),
-        BoolToBOOL(initiallyOwn), name);
-    return (_handle != 0);
-  }
-
-  bool Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
-  {
-    _handle = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
-    return (_handle != 0);
-  }
-
-  bool Set() { return BOOLToBool(::SetEvent(_handle)); }
-  bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
-  bool Reset() { return BOOLToBool(::ResetEvent(_handle)); }
-};
-
-class CEvent: public CBaseEvent
-{
-public:
-  CEvent() {};
-  CEvent(bool manualReset, bool initiallyOwn, 
-      LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES securityAttributes = NULL);
-};
-
-class CManualResetEvent: public CEvent
-{
-public:
-  CManualResetEvent(bool initiallyOwn = false, LPCTSTR name = NULL, 
-      LPSECURITY_ATTRIBUTES securityAttributes = NULL):
-    CEvent(true, initiallyOwn, name, securityAttributes) {};
-};
-
-class CAutoResetEvent: public CEvent
-{
-public:
-  CAutoResetEvent(bool initiallyOwn = false, LPCTSTR name = NULL, 
-      LPSECURITY_ATTRIBUTES securityAttributes = NULL):
-    CEvent(false, initiallyOwn, name, securityAttributes) {};
-};
-
 class CMutex: public CObject
 {
 public:
-  bool Create(bool initiallyOwn, LPCTSTR name = NULL,
+  HRes Create(bool initiallyOwn, LPCTSTR name = NULL,
       LPSECURITY_ATTRIBUTES securityAttributes = NULL)
   {
     _handle = ::CreateMutex(securityAttributes, BoolToBOOL(initiallyOwn), name);
-    return (_handle != 0);
+    if (_handle != 0)
+      return 0;
+    return ::GetLastError();
   }
-  bool Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
+  HRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
   {
     _handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);
-    return (_handle != 0);
+    if (_handle != 0)
+      return 0;
+    return ::GetLastError();
+  }
+  HRes Release() 
+  { 
+    return ::ReleaseMutex(_handle) ? 0 : ::GetLastError();
   }
-  bool Release() { return BOOLToBool(::ReleaseMutex(_handle)); }
 };
-
 class CMutexLock
 {
   CMutex *_object;
@@ -86,37 +125,33 @@ public:
   CMutexLock(CMutex &object): _object(&object) { _object->Lock(); } 
   ~CMutexLock() { _object->Release(); }
 };
+#endif
 
-class CSemaphore: public CObject
+class CSemaphore
 {
+  ::CSemaphore _object;
 public:
-  bool Create(LONG initiallyCount, LONG maxCount, LPCTSTR name = NULL,
-      LPSECURITY_ATTRIBUTES securityAttributes = NULL)
+  CSemaphore() { Semaphore_Construct(&_object); }
+  ~CSemaphore() { Close(); }
+  HRes Close() {  return Semaphore_Close(&_object); }
+  operator HANDLE() { return _object.handle; }
+  HRes Create(UInt32 initiallyCount, UInt32 maxCount)
   {
-    _handle = ::CreateSemaphore(securityAttributes, initiallyCount, maxCount, name);
-    return (_handle != 0);
-  }
-  bool Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
-  {
-    _handle = ::OpenSemaphore(desiredAccess, BoolToBOOL(inheritHandle), name);
-    return (_handle != 0);
-  }
-  bool Release(LONG releaseCount = 1, LPLONG previousCount = NULL) 
-  { 
-    return BOOLToBool(::ReleaseSemaphore(_handle, releaseCount, previousCount)); 
+    return Semaphore_Create(&_object, initiallyCount, maxCount);
   }
+  HRes Release() { return Semaphore_Release1(&_object); }
+  HRes Release(UInt32 releaseCount) { return Semaphore_ReleaseN(&_object, releaseCount); }
+  HRes Lock() { return Semaphore_Wait(&_object); }
 };
 
 class CCriticalSection
 {
-  CRITICAL_SECTION _object;
-  // void Initialize() { ::InitializeCriticalSection(&_object); }
-  // void Delete() { ::DeleteCriticalSection(&_object); }
+  ::CCriticalSection _object;
 public:
-  CCriticalSection() { ::InitializeCriticalSection(&_object); }
-  ~CCriticalSection() { ::DeleteCriticalSection(&_object); }
-  void Enter() { ::EnterCriticalSection(&_object); }
-  void Leave() { ::LeaveCriticalSection(&_object); }
+  CCriticalSection() { CriticalSection_Init(&_object); }
+  ~CCriticalSection() { CriticalSection_Delete(&_object); }
+  void Enter() { CriticalSection_Enter(&_object); }
+  void Leave() { CriticalSection_Leave(&_object); }
 };
 
 class CCriticalSectionLock

CPP/Windows/Thread.h

@@ -3,47 +3,35 @@
 #ifndef __WINDOWS_THREAD_H
 #define __WINDOWS_THREAD_H
 
-// #include <process.h>
+#include <process.h>
 
-#include "Handle.h"
 #include "Defs.h"
 
+extern "C" 
+{ 
+#include "../../C/Threads.h"
+}
+
 namespace NWindows {
 
-class CThread: public CHandle
+class CThread
 {
-  bool IsOpen() const { return _handle != 0; }
+  ::CThread thread;
 public:
-  bool Create(LPSECURITY_ATTRIBUTES threadAttributes, 
-      SIZE_T stackSize, LPTHREAD_START_ROUTINE startAddress,
-      LPVOID parameter, DWORD creationFlags, LPDWORD threadId)
-  {
-    _handle = ::CreateThread(threadAttributes, stackSize, startAddress,
-        parameter, creationFlags, threadId);
-    return (_handle != NULL);
-  }
-  bool Create(LPTHREAD_START_ROUTINE startAddress, LPVOID parameter)
-  {
-    DWORD threadId;
-    return Create(NULL, 0, startAddress, parameter, 0, &threadId);
-    /*
-    _handle = (HANDLE)_beginthreadex(NULL, 0, startAddress, parameter, 0, NULL);
-    return (_handle != NULL);
-    */
-  }
-
-  DWORD Resume() { return ::ResumeThread(_handle); }
-  DWORD Suspend() { return ::SuspendThread(_handle); }
-  bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(_handle, exitCode)); }
-  int GetPriority() { return ::GetThreadPriority(_handle); }
-  bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(_handle, priority)); }
-
-  bool Wait() 
-  { 
-    if (!IsOpen())
-      return true;
-    return (::WaitForSingleObject(_handle, INFINITE) == WAIT_OBJECT_0); 
-  }
+  CThread() { Thread_Construct(&thread); }
+  ~CThread() { Close(); }
+  HRes Close()  { return Thread_Close(&thread); }
+  HRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
+    { return Thread_Create(&thread, startAddress, parameter); }
+  HRes Wait() { return Thread_Wait(&thread); }
+  
+  #ifdef _WIN32
+  DWORD Resume() { return ::ResumeThread(thread.handle); }
+  DWORD Suspend() { return ::SuspendThread(thread.handle); }
+  bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread.handle, exitCode)); }
+  int GetPriority() { return ::GetThreadPriority(thread.handle); }
+  bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread.handle, priority)); }
+  #endif
 };
 
 }