seven_zip_ruby 1.0.0

data/ext/p7zip/CPP/Windows/Synchronization2.h

@@ -0,0 +1,218 @@
+// Windows/Synchronization.h
+
+#ifdef ENV_BEOS
+#include <Locker.h>
+#include <kernel/OS.h>
+#include <list>
+#endif
+
+/* Remark : WFMO = WaitForMultipleObjects */
+
+namespace NWindows { namespace NSynchronization { struct CBaseHandleWFMO; } }
+
+typedef NWindows::NSynchronization::CBaseHandleWFMO *HANDLE;
+
+DWORD WINAPI WaitForMultipleObjects( DWORD count, const HANDLE *handles, BOOL wait_all, DWORD timeout );
+
+namespace NWindows {
+namespace NSynchronization {
+
+#ifdef ENV_BEOS
+class CSynchro : BLocker, private Uncopyable
+{
+#define MAX_THREAD 256
+  thread_id _waiting[MAX_THREAD]; // std::list<thread_id> _waiting;
+  int index_waiting;
+public:
+  CSynchro() { index_waiting = 0; }
+  void Create() { index_waiting = 0; }
+  ~CSynchro() {}
+  void Enter() { Lock(); }
+  void Leave() { Unlock(); }
+  void WaitCond() { 
+    _waiting[index_waiting++] = find_thread(NULL); // _waiting.push_back(find_thread(NULL));
+    thread_id sender;
+    Unlock();
+    int msg = receive_data(&sender, NULL, 0);
+    Lock();
+  }
+  void LeaveAndSignal() {
+    // Unlock();
+    // Lock();
+    // for (std::list<thread_id>::iterator index = _waiting.begin(); index != _waiting.end(); index++)
+    for(int index = 0 ; index < index_waiting ; index++)
+    {
+       send_data(_waiting[index], '7zCN', NULL, 0);
+    }
+    index_waiting = 0; // _waiting.clear();
+    Unlock();
+  }
+};
+#else // #ifdef ENV_BEOS
+#ifdef DEBUG_SYNCHRO
+class CSynchro: private Uncopyable
+{
+  pthread_mutex_t _object;
+  pthread_cond_t _cond;
+  bool _isValid;
+  void dump_error(int ligne,int ret,const char *text,void *param);
+public:
+  CSynchro();
+  ~CSynchro();
+  void Create();
+  void Enter();
+  void Leave();
+  void WaitCond();
+  void LeaveAndSignal();
+};
+#else // #ifdef DEBUG_SYNCHRO
+class CSynchro : private Uncopyable
+{
+  pthread_mutex_t _object;
+  pthread_cond_t _cond;
+  bool _isValid;
+public:
+  CSynchro() { _isValid = false; }
+  ~CSynchro() {
+    if (_isValid) {
+      ::pthread_mutex_destroy(&_object);
+      ::pthread_cond_destroy(&_cond);
+    }
+    _isValid = false;
+  }
+  void Create() {
+    ::pthread_mutex_init(&_object,0);
+    ::pthread_cond_init(&_cond,0);
+  }
+  void Enter() { 
+     ::pthread_mutex_lock(&_object);
+  }
+  void Leave() {
+    ::pthread_mutex_unlock(&_object);
+  }
+  void WaitCond() { 
+    ::pthread_cond_wait(&_cond, &_object);
+  }
+  void LeaveAndSignal() { 
+    ::pthread_cond_broadcast(&_cond);
+    ::pthread_mutex_unlock(&_object);
+  }
+};
+#endif // #ifdef DEBUG_SYNCHRO
+#endif // #ifdef ENV_BEOS
+
+struct CBaseHandleWFMO // FIXME : private Uncopyable
+{
+  CSynchro *_sync;
+
+  CBaseHandleWFMO() { }
+
+  operator HANDLE() { return this; }
+  virtual bool IsSignaledAndUpdate() = 0;
+};
+
+class CBaseEventWFMO : public CBaseHandleWFMO
+{
+  bool _manual_reset;
+  bool _state;
+
+public:
+
+  bool IsCreated()  { return (this->_sync != 0); }
+  CBaseEventWFMO()  { this->_sync = 0; } 
+  ~CBaseEventWFMO() { Close(); }
+
+  WRes Close() { this->_sync = 0; return S_OK; }
+
+  WRes Create(CSynchro *sync,bool manualReset, bool initiallyOwn)
+  {
+    this->_sync         = sync;
+    this->_manual_reset = manualReset;
+    this->_state        = initiallyOwn;
+    return S_OK;
+  }
+
+  WRes Set() {
+    this->_sync->Enter();
+    this->_state = true;
+    this->_sync->LeaveAndSignal();
+    return S_OK;
+  }
+
+  WRes Reset() {
+    this->_sync->Enter();
+    this->_state = false;
+    this->_sync->Leave();
+    return S_OK;
+  }
+  virtual bool IsSignaledAndUpdate() {
+    if (this->_state == true) {
+      if (this->_manual_reset == false) this->_state = false;
+      return true;
+    }
+    return false;
+  }
+};
+
+class CManualResetEventWFMO: public CBaseEventWFMO
+{
+public:
+  WRes Create(CSynchro *sync,bool initiallyOwn = false) { return CBaseEventWFMO::Create(sync,true, initiallyOwn); }
+};
+
+class CAutoResetEventWFMO: public CBaseEventWFMO
+{
+public:
+  WRes Create(CSynchro *sync) { return CBaseEventWFMO::Create(sync,false, false); }
+  WRes CreateIfNotCreated(CSynchro *sync)
+  {
+    if (IsCreated())
+      return 0;
+    return CBaseEventWFMO::Create(sync,false, false);
+  }
+};
+
+class CSemaphoreWFMO : public CBaseHandleWFMO
+{
+  LONG _count;
+  LONG _maxCount;
+
+public:
+  CSemaphoreWFMO() : _count(0), _maxCount(0) { this->_sync=0;} 
+  WRes Create(CSynchro *sync,LONG initiallyCount, LONG maxCount)
+  {
+    if ((initiallyCount < 0) || (initiallyCount > maxCount) || (maxCount < 1)) return S_FALSE;
+    this->_sync     = sync;
+    this->_count    = initiallyCount;
+    this->_maxCount = maxCount;
+    return S_OK;
+  }
+  WRes Release(LONG releaseCount = 1) {
+    if (releaseCount < 1) return S_FALSE;
+
+    this->_sync->Enter();
+    LONG newCount = this->_count + releaseCount;
+    if (newCount > this->_maxCount)
+    {
+      this->_sync->Leave();
+      return S_FALSE;
+    }
+    this->_count = newCount;
+
+    this->_sync->LeaveAndSignal();
+
+    return S_OK;
+  }
+  WRes Close() { this->_sync=0; return S_OK; }
+
+  virtual bool IsSignaledAndUpdate() {
+    if (this->_count > 0) {
+      this->_count--;
+      return true;
+    }
+    return false;
+  }
+};
+
+}}
+

data/ext/p7zip/CPP/Windows/System.cpp

@@ -0,0 +1,166 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined (__NetBSD__) || defined(__OpenBSD__) || defined (__FreeBSD__) || defined (__FreeBSD_kernel__) || defined (__APPLE__)
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#elif defined(__linux__) || defined(__CYGWIN__) || defined(sun) || defined(__NETWARE__)
+#include <unistd.h>
+#elif defined(hpux) || defined(__hpux)
+#include <sys/param.h>
+#include <sys/pstat.h>
+#endif
+
+#if defined(__NETWARE__)
+#include <sys/sysinfo.h>
+#endif
+
+#if defined(ENV_BEOS)
+#include <be/kernel/OS.h>
+#endif
+
+
+#include "Common/Types.h"
+
+namespace NWindows
+{
+	namespace NSystem
+	{
+		/************************ GetNumberOfProcessors ************************/
+
+		#if defined (__NetBSD__) || defined(__OpenBSD__)
+		UInt32 GetNumberOfProcessors() {
+			int mib[2], value;
+		  	int nbcpu = 1;
+
+		  	mib[0] = CTL_HW;
+		  	mib[1] = HW_NCPU;
+		  	size_t len = sizeof(size_t);
+		  	if (sysctl(mib, 2, &value, &len, NULL, 0) >= 0)
+		  		if (value > nbcpu)
+					nbcpu = value;
+			return nbcpu;
+		}
+		#elif defined (__FreeBSD__) || defined (__FreeBSD_kernel__)
+		UInt32 GetNumberOfProcessors() {
+		  	int nbcpu = 1;
+			size_t value;
+			size_t len = sizeof(value);
+			if (sysctlbyname("hw.ncpu", &value, &len, NULL, 0) == 0)
+				nbcpu = value;
+			return nbcpu;
+		}
+		#elif defined (__APPLE__)
+		UInt32 GetNumberOfProcessors() {
+		  	int nbcpu = 1,value;
+			size_t valSize = sizeof(value);
+			if (sysctlbyname ("hw.ncpu", &value, &valSize, NULL, 0) == 0)
+				nbcpu = value;
+			return nbcpu;
+		}
+
+		#elif defined(__linux__) || defined(__CYGWIN__) || defined(sun)
+		UInt32 GetNumberOfProcessors() {
+		  	int nbcpu = sysconf (_SC_NPROCESSORS_CONF);
+			if (nbcpu < 1) nbcpu = 1;
+			return nbcpu;
+		}
+		#elif defined(hpux) || defined(__hpux)
+		UInt32 GetNumberOfProcessors() {
+			struct pst_dynamic psd;
+			if (pstat_getdynamic(&psd, sizeof(psd), (size_t)1, 0) != -1)
+				return (UInt32)psd.psd_proc_cnt;
+			return 1;
+		}
+		#elif defined(__NETWARE__)
+		UInt32 GetNumberOfProcessors() {
+			// int nbcpu = get_nprocs_conf();
+			int nbcpu = get_nprocs();
+			if (nbcpu < 1) nbcpu = 1;
+			return nbcpu;
+		}
+		#elif defined(ENV_BEOS)
+		UInt32 GetNumberOfProcessors() {
+			system_info info;
+			get_system_info(&info);
+			int nbcpu = info.cpu_count;
+			if (nbcpu < 1) nbcpu = 1;
+			return nbcpu;
+		}
+		#else
+		#warning Generic GetNumberOfProcessors
+		UInt32 GetNumberOfProcessors() {
+			return 1;
+		}
+		#endif
+
+		/************************ GetRamSize ************************/
+	UInt64 GetRamSize() {
+			UInt64 ullTotalPhys = 128 * 1024 * 1024; // default : 128MB
+
+#ifdef linux
+	 		FILE * f = fopen( "/proc/meminfo", "r" );
+	 		if (f)
+	 		{
+				char buffer[256];
+				unsigned long total;
+
+				ullTotalPhys = 0;
+
+		  		while (fgets( buffer, sizeof(buffer), f ))
+		  		{
+		 		/* old style /proc/meminfo ... */
+					if (sscanf( buffer, "Mem: %lu", &total))
+					{
+					 	ullTotalPhys += total;
+					}
+
+					/* new style /proc/meminfo ... */
+					if (sscanf(buffer, "MemTotal: %lu", &total))
+					 	ullTotalPhys = ((UInt64)total)*1024;
+		  		}
+		  		fclose( f );
+			}
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
+#ifdef HW_MEMSIZE
+			uint64_t val = 0; // support 2Gb+ RAM
+			int mib[2] = { CTL_HW, HW_MEMSIZE };
+#else // HW_MEMSIZE
+			unsigned int val = 0; // For old system
+			int mib[2] = { CTL_HW, HW_PHYSMEM };
+#endif // HW_MEMSIZE
+			size_t size_sys = sizeof(val);
+
+			sysctl(mib, 2, &val, &size_sys, NULL, 0);
+			if (val) ullTotalPhys = val;
+#elif defined(__CYGWIN__)
+			unsigned long pagesize=4096; // FIXME - sysconf(_SC_PAGESIZE) returns 65536 !?
+					// see http://readlist.com/lists/cygwin.com/cygwin/0/3313.html
+			unsigned long maxpages=sysconf(_SC_PHYS_PAGES);
+			ullTotalPhys = ((UInt64)pagesize)*maxpages;
+#elif defined ( sun ) || defined(__NETWARE__)
+			unsigned long pagesize=sysconf(_SC_PAGESIZE);
+			unsigned long maxpages=sysconf(_SC_PHYS_PAGES);
+			ullTotalPhys = ((UInt64)pagesize)*maxpages;
+#elif defined(hpux) || defined(__hpux)
+			struct pst_static pst;
+			union pstun pu;
+						
+			pu.pst_static = &pst;
+			if ( pstat( PSTAT_STATIC, pu, (size_t)sizeof(pst), (size_t)0, 0 ) != -1 ) {
+				ullTotalPhys = ((UInt64)pst.physical_memory)*pst.page_size;
+			}
+#elif defined(ENV_BEOS)
+			system_info info;
+			get_system_info(&info);
+			ullTotalPhys = info.max_pages;
+			ullTotalPhys *= 4096;
+#else
+#warning Generic GetRamSize
+#endif
+			return ullTotalPhys;
+		}
+
+	}
+}
+

data/ext/p7zip/CPP/Windows/System.h

@@ -0,0 +1,16 @@
+// Windows/System.h
+
+#ifndef __WINDOWS_SYSTEM_H
+#define __WINDOWS_SYSTEM_H
+
+#include "../Common/Types.h"
+
+namespace NWindows {
+namespace NSystem {
+
+UInt32 GetNumberOfProcessors();
+UInt64 GetRamSize();
+
+}}
+
+#endif

data/ext/p7zip/CPP/Windows/Thread.h

@@ -0,0 +1,41 @@
+// Windows/Thread.h
+
+#ifndef __WINDOWS_THREAD_H
+#define __WINDOWS_THREAD_H
+
+#include "Defs.h"
+
+extern "C"
+{
+#include "../../C/Threads.h"
+}
+
+namespace NWindows {
+
+class CThread
+{
+  ::CThread thread;
+public:
+  CThread() { Thread_Construct(&thread); }
+  ~CThread() { Close(); }
+  bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
+  WRes Close()  { return Thread_Close(&thread); }
+  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; }
+  DWORD Resume() { return ::ResumeThread(thread); }
+  DWORD Suspend() { return ::SuspendThread(thread); }
+  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

data/ext/p7zip/CPP/Windows/Time.cpp

@@ -0,0 +1,88 @@
+// Windows/Time.cpp
+
+#include "StdAfx.h"
+
+#include "Time.h"
+#include "Windows/Defs.h"
+
+namespace NWindows {
+namespace NTime {
+
+static const UInt32 kFileTimeStartYear = 1601;
+
+bool DosTimeToFileTime(UInt32 dosTime, FILETIME &fileTime)
+{
+  return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &fileTime));
+}
+
+static const UInt32 kHighDosTime = 0xFF9FBF7D;
+static const UInt32 kLowDosTime = 0x210000;
+
+bool FileTimeToDosTime(const FILETIME &fileTime, UInt32 &dosTime)
+{
+  WORD datePart, timePart;
+  if (!::FileTimeToDosDateTime(&fileTime, &datePart, &timePart))
+  {
+    dosTime = (fileTime.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
+    return false;
+  }
+  dosTime = (((UInt32)datePart) << 16) + timePart;
+  return true;
+}
+
+static const UInt32 kNumTimeQuantumsInSecond = 10000000;
+static const UInt64 kUnixTimeStartValue = ((UInt64)kNumTimeQuantumsInSecond) * 60 * 60 * 24 * 134774;
+
+void UnixTimeToFileTime(UInt32 unixTime, FILETIME &fileTime)
+{
+  UInt64 v = kUnixTimeStartValue + ((UInt64)unixTime) * kNumTimeQuantumsInSecond;
+  fileTime.dwLowDateTime = (DWORD)v;
+  fileTime.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+bool FileTimeToUnixTime(const FILETIME &fileTime, UInt32 &unixTime)
+{
+  UInt64 winTime = (((UInt64)fileTime.dwHighDateTime) << 32) + fileTime.dwLowDateTime;
+  if (winTime < kUnixTimeStartValue)
+  {
+    unixTime = 0;
+    return false;
+  }
+  winTime = (winTime - kUnixTimeStartValue) / kNumTimeQuantumsInSecond;
+  if (winTime > 0xFFFFFFFF)
+  {
+    unixTime = 0xFFFFFFFF;
+    return false;
+  }
+  unixTime = (UInt32)winTime;
+  return true;
+}
+
+bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
+  unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds)
+{
+  resSeconds = 0;
+  if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
+      day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
+    return false;
+  UInt32 numYears = year - kFileTimeStartYear;
+  UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
+  Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+  if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
+    ms[1] = 29;
+  month--;
+  for (unsigned i = 0; i < month; i++)
+    numDays += ms[i];
+  numDays += day - 1;
+  resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
+  return true;
+}
+
+void GetCurUtcFileTime(FILETIME &ft)
+{
+  SYSTEMTIME st;
+  GetSystemTime(&st);
+  SystemTimeToFileTime(&st, &ft);
+}
+
+}}