seven_zip_ruby_am 1.2.5.1

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

@@ -0,0 +1,56 @@
+// Windows/PropVariant.h
+
+#ifndef __WINDOWS_PROPVARIANT_H
+#define __WINDOWS_PROPVARIANT_H
+
+#include "../Common/MyWindows.h"
+#include "../Common/Types.h"
+
+namespace NWindows {
+namespace NCOM {
+
+class CPropVariant : public tagPROPVARIANT
+{
+public:
+  CPropVariant() { vt = VT_EMPTY; wReserved1 = 0; }
+  ~CPropVariant() { Clear(); }
+  CPropVariant(const PROPVARIANT &varSrc);
+  CPropVariant(const CPropVariant &varSrc);
+  CPropVariant(BSTR bstrSrc);
+  CPropVariant(LPCOLESTR lpszSrc);
+  CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); };
+  CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
+  CPropVariant(Int16 value) { vt = VT_I2; wReserved1 = 0; iVal = value; }
+  CPropVariant(Int32 value) { vt = VT_I4; wReserved1 = 0; lVal = value; }
+  CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
+  CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
+  CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
+
+  CPropVariant& operator=(const CPropVariant &varSrc);
+  CPropVariant& operator=(const PROPVARIANT &varSrc);
+  CPropVariant& operator=(BSTR bstrSrc);
+  CPropVariant& operator=(LPCOLESTR lpszSrc);
+  CPropVariant& operator=(const char *s);
+  CPropVariant& operator=(bool bSrc);
+  CPropVariant& operator=(Byte value);
+  CPropVariant& operator=(Int16 value);
+  CPropVariant& operator=(Int32 value);
+  CPropVariant& operator=(UInt32 value);
+  CPropVariant& operator=(Int64 value);
+  CPropVariant& operator=(UInt64 value);
+  CPropVariant& operator=(const FILETIME &value);
+
+  HRESULT Clear();
+  HRESULT Copy(const PROPVARIANT *pSrc);
+  HRESULT Attach(PROPVARIANT *pSrc);
+  HRESULT Detach(PROPVARIANT *pDest);
+
+  HRESULT InternalClear();
+  void InternalCopy(const PROPVARIANT *pSrc);
+
+  int Compare(const CPropVariant &a1);
+};
+
+}}
+
+#endif

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

@@ -0,0 +1,142 @@
+// PropVariantConversions.cpp
+
+#include "StdAfx.h"
+
+#include "Common/IntToString.h"
+#include "Common/StringConvert.h"
+
+#include "Windows/Defs.h"
+
+#include "PropVariantConversions.h"
+
+static UString ConvertUInt64ToString(UInt64 value)
+{
+  wchar_t buffer[32];
+  ConvertUInt64ToString(value, buffer);
+  return buffer;
+}
+
+static UString ConvertInt64ToString(Int64 value)
+{
+  wchar_t buffer[32];
+  ConvertInt64ToString(value, buffer);
+  return buffer;
+}
+
+#ifdef _WIN32
+static char *UIntToStringSpec(char c, UInt32 value, char *s, int numPos)
+{
+  if (c != 0)
+    *s++ = c;
+  char temp[16];
+  int pos = 0;
+  do
+  {
+    temp[pos++] = (char)('0' + value % 10);
+    value /= 10;
+  }
+  while (value != 0);
+  int i;
+  for (i = 0; i < numPos - pos; i++)
+    *s++ = '0';
+  do
+    *s++ = temp[--pos];
+  while (pos > 0);
+  *s = '\0';
+  return s;
+}
+#endif
+
+bool ConvertFileTimeToString(const FILETIME &ft, char *s, bool includeTime, bool includeSeconds)
+{
+#ifdef _WIN32
+  s[0] = '\0';
+  SYSTEMTIME st;
+  if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
+    return false;
+  s = UIntToStringSpec(0, st.wYear, s, 4);
+  s = UIntToStringSpec('-', st.wMonth, s, 2);
+  s = UIntToStringSpec('-', st.wDay, s, 2);
+  if (includeTime)
+  {
+    s = UIntToStringSpec(' ', st.wHour, s, 2);
+    s = UIntToStringSpec(':', st.wMinute, s, 2);
+    if (includeSeconds)
+      UIntToStringSpec(':', st.wSecond, s, 2);
+  }
+  /*
+  sprintf(s, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
+  if (includeTime)
+  {
+    sprintf(s + strlen(s), " %02d:%02d", st.wHour, st.wMinute);
+    if (includeSeconds)
+      sprintf(s + strlen(s), ":%02d", st.wSecond);
+  }
+  */
+#else
+  BOOLEAN WINAPI RtlTimeToSecondsSince1970( const LARGE_INTEGER *Time, DWORD *Seconds );
+
+  FILETIME filetime;
+  LocalFileTimeToFileTime(&ft, &filetime);
+
+  LARGE_INTEGER  ltime;
+
+  ltime.QuadPart = filetime.dwHighDateTime;
+  ltime.QuadPart = (ltime.QuadPart << 32) | filetime.dwLowDateTime;
+
+  DWORD dw;
+  RtlTimeToSecondsSince1970(&ltime, &dw );
+  time_t timep = (time_t)dw;
+
+  struct tm * date = localtime(&timep);
+
+  sprintf(s, "%04d-%02d-%02d", date->tm_year+1900, date->tm_mon+1,date->tm_mday);
+  if (includeTime)
+  {
+    sprintf(s + strlen(s), " %02d:%02d", date->tm_hour,date->tm_min);
+    if (includeSeconds)
+      sprintf(s + strlen(s), ":%02d", date->tm_sec);
+  }
+#endif
+  return true;
+}
+
+UString ConvertFileTimeToString(const FILETIME &ft, bool includeTime, bool includeSeconds)
+{
+  char s[32];
+  ConvertFileTimeToString(ft, s, includeTime, includeSeconds);
+  return GetUnicodeString(s);
+}
+ 
+
+UString ConvertPropVariantToString(const PROPVARIANT &prop)
+{
+  switch (prop.vt)
+  {
+    case VT_EMPTY: return UString();
+    case VT_BSTR: return prop.bstrVal;
+    case VT_UI1: return ConvertUInt64ToString(prop.bVal);
+    case VT_UI2: return ConvertUInt64ToString(prop.uiVal);
+    case VT_UI4: return ConvertUInt64ToString(prop.ulVal);
+    case VT_UI8: return ConvertUInt64ToString(prop.uhVal.QuadPart);
+    case VT_FILETIME: return ConvertFileTimeToString(prop.filetime, true, true);
+    // case VT_I1: return ConvertInt64ToString(prop.cVal);
+    case VT_I2: return ConvertInt64ToString(prop.iVal);
+    case VT_I4: return ConvertInt64ToString(prop.lVal);
+    case VT_I8: return ConvertInt64ToString(prop.hVal.QuadPart);
+    case VT_BOOL: return VARIANT_BOOLToBool(prop.boolVal) ? L"+" : L"-";
+    default: throw 150245;
+  }
+}
+
+UInt64 ConvertPropVariantToUInt64(const PROPVARIANT &prop)
+{
+  switch (prop.vt)
+  {
+    case VT_UI1: return prop.bVal;
+    case VT_UI2: return prop.uiVal;
+    case VT_UI4: return prop.ulVal;
+    case VT_UI8: return (UInt64)prop.uhVal.QuadPart;
+    default: throw 151199;
+  }
+}

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

@@ -0,0 +1,14 @@
+// Windows/PropVariantConversions.h
+
+#ifndef __PROP_VARIANT_CONVERSIONS_H
+#define __PROP_VARIANT_CONVERSIONS_H
+
+#include "Common/MyString.h"
+#include "Common/Types.h"
+
+bool ConvertFileTimeToString(const FILETIME &ft, char *s, bool includeTime = true, bool includeSeconds = true);
+UString ConvertFileTimeToString(const FILETIME &ft, bool includeTime = true, bool includeSeconds = true);
+UString ConvertPropVariantToString(const PROPVARIANT &prop);
+UInt64 ConvertPropVariantToUInt64(const PROPVARIANT &prop);
+
+#endif

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

@@ -0,0 +1,78 @@
+// PropVariantUtils.cpp
+
+#include "StdAfx.h"
+
+#include "PropVariantUtils.h"
+#include "Common/StringConvert.h"
+#include "Common/IntToString.h"
+
+using namespace NWindows;
+
+static AString GetHex(UInt32 v)
+{
+  char sz[32] = { '0', 'x' };
+  ConvertUInt64ToString(v, sz + 2, 16);
+  return sz;
+}
+
+void StringToProp(const AString &s, NCOM::CPropVariant &prop)
+{
+  prop = MultiByteToUnicodeString(s);
+}
+
+void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+{
+  AString s;
+  for (unsigned i = 0; i < num; i++)
+  {
+    const CUInt32PCharPair &p = pairs[i];
+    if (p.Value == value)
+      s = p.Name;
+  }
+  if (s.IsEmpty())
+    s = GetHex(value);
+  StringToProp(s, prop);
+}
+
+AString TypeToString(const char *table[], unsigned num, UInt32 value)
+{
+  if (value < num)
+    return table[value];
+  return GetHex(value);
+}
+
+void TypeToProp(const char *table[], unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+{
+  StringToProp(TypeToString(table, num, value), prop);
+}
+
+
+AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
+{
+  AString s;
+  for (unsigned i = 0; i < num; i++)
+  {
+    const CUInt32PCharPair &p = pairs[i];
+    UInt32 flag = (UInt32)1 << (unsigned)p.Value;
+    if ((flags & flag) != 0)
+    {
+      if (!s.IsEmpty())
+        s += ' ';
+      s += p.Name;
+    }
+    flags &= ~flag;
+  }
+  if (flags != 0)
+  {
+    if (!s.IsEmpty())
+      s += ' ';
+    s += GetHex(flags);
+  }
+  return s;
+}
+
+void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
+{
+  StringToProp(FlagsToString(pairs, num, flags), prop);
+}
+

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

@@ -0,0 +1,28 @@
+// Windows/PropVariantUtils.h
+
+#ifndef __PROP_VARIANT_UTILS_H
+#define __PROP_VARIANT_UTILS_H
+
+#include "Common/MyString.h"
+#include "PropVariant.h"
+
+struct CUInt32PCharPair
+{
+  UInt32 Value;
+  const char *Name;
+};
+
+void StringToProp(const AString &s, NWindows::NCOM::CPropVariant &prop);
+void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+
+AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags);
+void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
+
+AString TypeToString(const char *table[], unsigned num, UInt32 value);
+void TypeToProp(const char *table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+
+#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, sizeof(pairs) / sizeof(pairs[0]), value, prop)
+#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, sizeof(pairs) / sizeof(pairs[0]), value, prop)
+#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, sizeof(table) / sizeof(table[0]), value, prop)
+
+#endif

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

@@ -0,0 +1,313 @@
+// Windows/Registry.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "Common/StringConvert.h"
+#endif
+#include "Windows/Registry.h"
+
+#include <wx/config.h>
+
+class HKEY_Impl
+{
+  public:
+	wxString path;
+	HKEY_Impl(wxString a) : path(a) {}
+};
+
+namespace NWindows {
+namespace NRegistry {
+
+#define ERROR_SET_VALUE (E_INVALIDARG) // FIXME
+#define ERROR_GET_VALUE (E_INVALIDARG) // FIXME
+#define PROGRAM_NAME L"p7zip"
+
+static wxConfig * g_config = 0;
+static int        g_config_ref = 0;
+
+static void configAddRef() {
+	if (g_config == 0) {
+		g_config = new wxConfig(PROGRAM_NAME);
+		g_config->Flush(true);
+		wxConfigBase::Set(g_config);
+	}
+	g_config_ref++;
+}
+
+static void configSubRef() {
+	if (g_config_ref >= 1)
+	{
+		g_config_ref--;
+		if (g_config_ref == 0) {
+			delete g_config;
+			g_config = 0;
+			wxConfigBase::Set(NULL);
+		} else {
+			g_config->Flush(true);
+		}
+	}
+}
+
+	LONG CKey::Close()
+	{
+		if (_object) 
+		{
+			configSubRef();
+			delete _object;
+		}
+		_object = 0;
+		return ERROR_SUCCESS;
+	}
+
+	LONG CKey::Create(HKEY parentKey, LPCTSTR keyName)
+	{
+		Close();
+
+		configAddRef();
+
+		wxString path;
+
+		if (parentKey == HKEY_CURRENT_USER) {
+			path=L"/" + wxString(keyName);
+		} else {
+			path = parentKey->path + L"/" + wxString(keyName);
+		}
+		_object = new HKEY_Impl(path);
+		return ERROR_SUCCESS;
+	}
+	LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask)
+	{
+		Close();
+
+		configAddRef();
+
+		wxString path;
+
+		if (parentKey == HKEY_CURRENT_USER) {
+			path=L"/" + wxString(keyName);
+		} else {
+			path = parentKey->path + L"/" + wxString(keyName);
+		}
+		_object = new HKEY_Impl(path);
+		return ERROR_SUCCESS;
+	}
+
+	LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->DeleteGroup(subKeyName);
+		if (ret) return ERROR_SUCCESS;
+		return ERROR_GET_VALUE;
+	}
+
+	LONG CKey::DeleteValue(LPCTSTR name)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->DeleteEntry(name);
+		if (ret) return ERROR_SUCCESS;
+		return ERROR_GET_VALUE;
+	}
+
+	LONG CKey::QueryValue(LPCTSTR name, UInt32 &value)
+	{
+		g_config->SetPath(_object->path);
+		long val;
+		bool ret = g_config->Read(name,&val);
+		if (ret) {
+			value = (UInt32)val;
+			return ERROR_SUCCESS;
+		}
+		return ERROR_GET_VALUE;
+	}
+
+	LONG CKey::QueryValue(LPCTSTR name, bool &value)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->Read(name,&value);
+		if (ret) return ERROR_SUCCESS;
+		return ERROR_GET_VALUE;
+	}
+
+	LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
+	{
+		g_config->SetPath(_object->path);
+		wxString val;
+		bool ret = g_config->Read(name,&val);
+		if (ret) {
+			value = val;
+			return ERROR_SUCCESS;
+		}
+		return ERROR_GET_VALUE;
+	}
+
+LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value)
+{
+  UInt32 newVal;
+  LONG res = QueryValue(name, newVal);
+  if (res == ERROR_SUCCESS)
+    value = newVal;
+  return res;
+}
+
+LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value)
+{
+  bool newVal;
+  LONG res = QueryValue(name, newVal);
+  if (res == ERROR_SUCCESS)
+    value = newVal;
+  return res;
+}
+
+
+	LONG CKey::SetValue(LPCTSTR valueName, UInt32 value)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->Write(valueName,(long)value);
+		if (ret == true) return ERROR_SUCCESS;
+		return ERROR_SET_VALUE;
+	}
+	LONG CKey::SetValue(LPCTSTR valueName, bool value)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->Write(valueName,value);
+		if (ret == true) return ERROR_SUCCESS;
+		return ERROR_SET_VALUE;
+	}
+	LONG CKey::SetValue(LPCTSTR valueName, LPCTSTR value)
+	{
+		g_config->SetPath(_object->path);
+		bool ret = g_config->Write(valueName,value);
+		if (ret == true) return ERROR_SUCCESS;
+		return ERROR_SET_VALUE;
+	}
+
+	LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size)
+	{
+		static char hexa[] = "0123456789ABCDEF";
+		/* FIXME
+		MYASSERT(value != NULL);
+		MYASSERT(_object != NULL);
+		return RegSetValueEx(_object, name, NULL, REG_BINARY, (const BYTE *)value, size);
+		*/
+		BYTE *buf = (BYTE *)value;
+		wxString str;
+		for(UInt32 i=0;i<size;i++)
+		{
+			str += 	hexa[ (buf[i]>>4) & 0x0f];
+			str += 	hexa[ buf[i] & 0x0f];
+		}
+		return SetValue(name,(LPCTSTR)str);
+	}
+
+	LONG CKey::EnumKeys(CSysStringVector &keyNames)
+	{
+		g_config->SetPath(_object->path);
+		keyNames.Clear();
+		// enumeration variables
+		wxString str;
+		long dummy;
+		bool bCont = g_config->GetFirstEntry(str, dummy);
+		while ( bCont ) {
+			keyNames.Add((const TCHAR *)str);
+			bCont = g_config->GetNextEntry(str, dummy);
+		}
+
+		// now all groups...
+		bCont = g_config->GetFirstGroup(str, dummy);
+		while ( bCont ) {
+			keyNames.Add((const TCHAR *)str);
+			bCont = g_config->GetNextGroup(str, dummy);
+  		}
+		return ERROR_SUCCESS;
+	}
+
+	LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &dataSize)
+	{
+		g_config->SetPath(_object->path);
+		wxString str;
+		bool ret = g_config->Read(name,&str);
+		if (ret == false) return ERROR_GET_VALUE;
+
+		size_t l =  str.Len() / 2;
+		if (l > dataSize) l = dataSize;
+		else              dataSize=l;
+
+		BYTE *buf = (BYTE *)value;
+		for(UInt32 i=0;i<dataSize;i++)
+		{
+			char cval[3];
+			cval[0] = (char)str[2*i];
+			cval[1] = (char)str[2*i+1];
+			cval[2] = 0;
+			unsigned uval = 0;
+			sscanf(cval,"%x",&uval);
+			buf[i]=(BYTE)uval;
+		}
+
+		return ERROR_SUCCESS;
+	}
+
+
+	LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
+	{
+		g_config->SetPath(_object->path);
+		wxString str;
+		bool ret = g_config->Read(name,&str);
+		if (ret == false) return ERROR_GET_VALUE;
+
+		dataSize =  str.Len() / 2;
+		value.SetCapacity(dataSize);
+		return QueryValue(name, (BYTE *)value, dataSize);
+	}
+
+
+LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
+{
+  UInt32 numChars = 0;
+  int i;
+  for (i = 0; i < strings.Size(); i++)
+    numChars += strings[i].Length() + 1;
+  CBuffer<wchar_t> buffer;
+  buffer.SetCapacity(numChars);
+  int pos = 0;
+  for (i = 0; i < strings.Size(); i++)
+  {
+    const UString &s = strings[i];
+    MyStringCopy((wchar_t *)buffer + pos, (const wchar_t *)s);
+    pos += s.Length() + 1;
+  }
+  return SetValue(valueName, buffer, numChars * sizeof(wchar_t));
+}
+
+LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
+{
+  strings.Clear();
+  CByteBuffer buffer;
+  UInt32 dataSize;
+  LONG res = QueryValue(valueName, buffer, dataSize);
+  if (res != ERROR_SUCCESS)
+    return res;
+  if (dataSize % sizeof(wchar_t) != 0)
+    return E_FAIL;
+  const wchar_t *data = (const wchar_t *)(const Byte  *)buffer;
+  int numChars = dataSize / sizeof(wchar_t);
+  UString s;
+  for (int i = 0; i < numChars; i++)
+  {
+    wchar_t c = data[i];
+    if (c == 0)
+    {
+      strings.Add(s);
+      s.Empty();
+    }
+    else
+      s += c;
+  }
+  return res;
+}
+
+
+}
+}
+