react-native-update 10.34.3 → 10.34.5

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

@@ -3,7 +3,6 @@
 #include "StdAfx.h"
 
 #include <wchar.h>
-// #include <stdio.h>
 
 #ifndef _UNICODE
 #include "../Common/StringConvert.h"
@@ -18,27 +17,12 @@ namespace NWindows {
 namespace NRegistry {
 
 #define MYASSERT(expr) // _ASSERTE(expr)
-#define MY_ASSUME(expr)
-
-/*
-static void Error()
-{
-  #ifdef _CONSOLE
-  printf("\nregistry error\n");
-  #else
-  MessageBoxW(0, L"registry error", L"", 0);
-  // exit(1);
-  #endif
-}
-
-#define MY_ASSUME(expr) { if (!(expr)) Error(); }
-*/
 
 LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
     LPTSTR keyClass, DWORD options, REGSAM accessMask,
     LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
 {
-  MY_ASSUME(parentKey != NULL);
+  MYASSERT(parentKey != NULL);
   DWORD dispositionReal;
   HKEY key = NULL;
   LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
@@ -55,7 +39,7 @@ LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
 
 LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
 {
-  MY_ASSUME(parentKey != NULL);
+  MYASSERT(parentKey != NULL);
   HKEY key = NULL;
   LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
   if (res == ERROR_SUCCESS)
@@ -78,46 +62,32 @@ LONG CKey::Close() throw()
   return res;
 }
 
-// win95, win98: deletes subkey and all its subkeys
+// win95, win98: deletes sunkey and all its subkeys
 // winNT to be deleted must not have subkeys
 LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
 {
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   return RegDeleteKey(_object, subKeyName);
 }
 
 LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
 {
+  CKey key;
+  LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
+  if (res != ERROR_SUCCESS)
+    return res;
+  FILETIME fileTime;
+  const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
+  DWORD size = kBufSize;
+  TCHAR buffer[kBufSize];
+  while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
   {
-    CKey key;
-    LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
+    res = key.RecurseDeleteKey(buffer);
     if (res != ERROR_SUCCESS)
       return res;
-    FILETIME fileTime;
-    const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
-    TCHAR buffer[kBufSize];
-    // we use loop limit here for some unexpected code failure
-    for (unsigned loop_cnt = 0; loop_cnt < (1u << 26); loop_cnt++)
-    {
-      DWORD size = kBufSize;
-      // we always request starting item (index==0) in each iteration,
-      // because we remove starting item (index==0) in each loop iteration.
-      res = RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime);
-      if (res != ERROR_SUCCESS)
-      {
-        // possible return codes:
-        //   ERROR_NO_MORE_ITEMS : are no more subkeys available
-        //   ERROR_MORE_DATA     : name buffer is too small
-        // we can try to remove (subKeyName), even if there is non ERROR_NO_MORE_ITEMS error.
-        // if (res != ERROR_NO_MORE_ITEMS) return res;
-        break;
-      }
-      res = key.RecurseDeleteKey(buffer);
-      if (res != ERROR_SUCCESS)
-        return res;
-    }
-    // key.Close();
+    size = kBufSize;
   }
+  key.Close();
   return DeleteSubKey(subKeyName);
 }
 
@@ -131,25 +101,25 @@ static inline bool UINT32ToBool(UInt32 value) {  return (value != 0); }
 
 LONG CKey::DeleteValue(LPCTSTR name) throw()
 {
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   return ::RegDeleteValue(_object, name);
 }
 
 #ifndef _UNICODE
 LONG CKey::DeleteValue(LPCWSTR name)
 {
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   if (g_IsNT)
     return ::RegDeleteValueW(_object, name);
-  return DeleteValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name));
+  return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
 }
 #endif
 
 LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
 {
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   return RegSetValueEx(_object, name, 0, REG_DWORD,
-      (const BYTE *)&value, sizeof(UInt32));
+      (BYTE * const)&value, sizeof(UInt32));
 }
 
 LONG CKey::SetValue(LPCTSTR name, bool value) throw()
@@ -157,23 +127,20 @@ LONG CKey::SetValue(LPCTSTR name, bool value) throw()
   return SetValue(name, BoolToUINT32(value));
 }
 
-
-// value must be string that is NULL terminated
 LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
 {
   MYASSERT(value != NULL);
-  MY_ASSUME(_object != NULL);
-  // note: RegSetValueEx supports (value == NULL), if (cbData == 0)
+  MYASSERT(_object != NULL);
   return RegSetValueEx(_object, name, 0, REG_SZ,
-      (const BYTE *)value, (DWORD)(((DWORD)lstrlen(value) + 1) * sizeof(TCHAR)));
+      (const BYTE * )value, (lstrlen(value) + 1) * sizeof(TCHAR));
 }
 
 /*
 LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
 {
   MYASSERT(value != NULL);
-  MY_ASSUME(_object != NULL);
-  return RegSetValueEx(_object, name, 0, REG_SZ,
+  MYASSERT(_object != NULL);
+  return RegSetValueEx(_object, name, NULL, REG_SZ,
       (const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
 }
 */
@@ -183,13 +150,12 @@ LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
 LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
 {
   MYASSERT(value != NULL);
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   if (g_IsNT)
     return RegSetValueExW(_object, name, 0, REG_SZ,
-        (const BYTE *)value, (DWORD)(((DWORD)wcslen(value) + 1) * sizeof(wchar_t)));
-  return SetValue(name == NULL ? NULL :
-        (LPCSTR)GetSystemString(name),
-        (LPCSTR)GetSystemString(value));
+      (const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
+  return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
+    value == 0 ? 0 : (LPCSTR)GetSystemString(value));
 }
 
 #endif
@@ -198,7 +164,7 @@ LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
 LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
 {
   MYASSERT(value != NULL);
-  MY_ASSUME(_object != NULL);
+  MYASSERT(_object != NULL);
   return RegSetValueEx(_object, name, 0, REG_BINARY,
       (const BYTE *)value, size);
 }
@@ -223,182 +189,130 @@ LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw(
   return res;
 }
 
-
-LONG CKey::GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw()
+LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
 {
   DWORD type = 0;
-  DWORD count = sizeof(value);
-  UInt32 value2; // = value;
-  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
-  if (res == ERROR_SUCCESS)
-  {
-    // ERROR_UNSUPPORTED_TYPE
-    if (count != sizeof(value) || type != REG_DWORD)
-      return ERROR_UNSUPPORTED_TYPE; // ERROR_INVALID_DATA;
-    value = value2;
-  }
+  DWORD count = sizeof(DWORD);
+  LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type,
+    (LPBYTE)&value, &count);
+  MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
+  MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
   return res;
 }
 
-LONG CKey::GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw()
+LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
 {
-  DWORD type = 0;
-  DWORD count = sizeof(value);
-  UInt64 value2; // = value;
-  const LONG res = QueryValueEx(name, &type, (LPBYTE)&value2, &count);
-  if (res == ERROR_SUCCESS)
-  {
-    if (count != sizeof(value) || type != REG_QWORD)
-      return ERROR_UNSUPPORTED_TYPE;
-    value = value2;
-  }
+  UInt32 uintValue = BoolToUINT32(value);
+  LONG res = QueryValue(name, uintValue);
+  value = UINT32ToBool(uintValue);
   return res;
 }
 
-LONG CKey::GetValue_bool_IfOk(LPCTSTR name, bool &value) throw()
+LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
 {
-  UInt32 uintValue;
-  const LONG res = GetValue_UInt32_IfOk(name, uintValue);
+  UInt32 newVal;
+  LONG res = QueryValue(name, newVal);
   if (res == ERROR_SUCCESS)
-    value = UINT32ToBool(uintValue);
+    value = newVal;
   return res;
 }
 
+LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
+{
+  bool newVal;
+  LONG res = QueryValue(name, newVal);
+  if (res == ERROR_SUCCESS)
+    value = newVal;
+  return res;
+}
 
+LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
+{
+  DWORD type = 0;
+  LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+  MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+  return res;
+}
 
 LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
 {
   value.Empty();
-  LONG res = ERROR_SUCCESS;
-  {
-    // if we don't want multiple calls here,
-    // we can use big value (264) here.
-    // 3 is default available length in new string.
-    DWORD size_prev = 3 * sizeof(TCHAR);
-    // at least 2 attempts are required. But we use more attempts for cases,
-    // where string can be changed by anothner process
-    for (unsigned i = 0; i < 2 + 2; i++)
-    {
-      DWORD type = 0;
-      DWORD size = size_prev;
-      {
-        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(TCHAR));
-        res = QueryValueEx(name, &type, size == 0 ? NULL : buf, &size);
-        // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
-      }
-      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
-      {
-        if (type != REG_SZ && type != REG_EXPAND_SZ)
-        {
-          res = ERROR_UNSUPPORTED_TYPE;
-          size = 0;
-        }
-      }
-      else
-        size = 0;
-      if (size > size_prev)
-      {
-        size_prev = size;
-        size = 0;
-        res = ERROR_MORE_DATA;
-      }
-      value.ReleaseBuf_CalcLen(size / sizeof(TCHAR));
-      if (res != ERROR_MORE_DATA)
-        return res;
-    }
-  }
+  DWORD type = 0;
+  UInt32 curSize = 0;
+  LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&curSize);
+  if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+    return res;
+  UInt32 curSize2 = curSize;
+  res = QueryValue(name, value.GetBuf(curSize), curSize2);
+  if (curSize > curSize2)
+    curSize = curSize2;
+  value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
   return res;
 }
 
 
 #ifndef _UNICODE
 
+LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
+{
+  DWORD type = 0;
+  LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+  MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
+  return res;
+}
+
 LONG CKey::QueryValue(LPCWSTR name, UString &value)
 {
   value.Empty();
-  LONG res = ERROR_SUCCESS;
+  DWORD type = 0;
+  UInt32 curSize = 0;
+
+  LONG res;
+
   if (g_IsNT)
   {
-    DWORD size_prev = 3 * sizeof(wchar_t);
-    for (unsigned i = 0; i < 2 + 2; i++)
-    {
-      DWORD type = 0;
-      DWORD size = size_prev;
-      {
-        LPBYTE buf = (LPBYTE)value.GetBuf(size / sizeof(wchar_t));
-        res = RegQueryValueExW(_object, name, NULL, &type,
-            size == 0 ? NULL : buf, &size);
-      }
-      if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
-      {
-        if (type != REG_SZ && type != REG_EXPAND_SZ)
-        {
-          res = ERROR_UNSUPPORTED_TYPE;
-          size = 0;
-        }
-      }
-      else
-        size = 0;
-      if (size > size_prev)
-      {
-        size_prev = size;
-        size = 0;
-        res = ERROR_MORE_DATA;
-      }
-      value.ReleaseBuf_CalcLen(size / sizeof(wchar_t));
-      if (res != ERROR_MORE_DATA)
-        return res;
-    }
+    res = RegQueryValueExW(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
+    if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+      return res;
+    UInt32 curSize2 = curSize;
+    res = QueryValue(name, value.GetBuf(curSize), curSize2);
+    if (curSize > curSize2)
+      curSize = curSize2;
+    value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
   }
   else
   {
     AString vTemp;
-    res = QueryValue(name == NULL ? NULL : (LPCSTR)GetSystemString(name), vTemp);
+    res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
     value = GetUnicodeString(vTemp);
   }
+  
   return res;
 }
 
 #endif
 
 
-LONG CKey::QueryValue_Binary(LPCTSTR name, CByteBuffer &value)
+LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
 {
-  // value.Free();
-  DWORD size_prev = 0;
-  LONG res = ERROR_SUCCESS;
-  for (unsigned i = 0; i < 2 + 2; i++)
-  {
-    DWORD type = 0;
-    DWORD size = size_prev;
-    value.Alloc(size_prev);
-    res = QueryValueEx(name, &type, value.NonConstData(), &size);
-    // if (size_prev == 0), then (res == ERROR_SUCCESS) is expected here, because we requested only size.
-    if (res == ERROR_SUCCESS || res == ERROR_MORE_DATA)
-    {
-      if (type != REG_BINARY)
-      {
-        res = ERROR_UNSUPPORTED_TYPE;
-        size = 0;
-      }
-    }
-    else
-      size = 0;
-    if (size > size_prev)
-    {
-      size_prev = size;
-      size = 0;
-      res = ERROR_MORE_DATA;
-    }
-    if (size < value.Size())
-      value.ChangeSize_KeepData(size, size);
-    if (res != ERROR_MORE_DATA)
-      return res;
-  }
+  DWORD type = 0;
+  LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
+  MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
   return res;
 }
 
 
+LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
+{
+  DWORD type = 0;
+  dataSize = 0;
+  LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&dataSize);
+  if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
+    return res;
+  value.Alloc(dataSize);
+  return QueryValue(name, (BYTE *)value, dataSize);
+}
+
 LONG CKey::EnumKeys(CSysStringVector &keyNames)
 {
   keyNames.Clear();
@@ -407,23 +321,23 @@ LONG CKey::EnumKeys(CSysStringVector &keyNames)
   {
     const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
     FILETIME lastWriteTime;
-    DWORD nameSize = kBufSize;
-    const LONG res = ::RegEnumKeyEx(_object, index,
-        keyName.GetBuf(kBufSize), &nameSize,
-        NULL, NULL, NULL, &lastWriteTime);
+    UInt32 nameSize = kBufSize;
+    LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
+        (DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
     keyName.ReleaseBuf_CalcLen(kBufSize);
-    if (res == ERROR_NO_MORE_ITEMS)
-      return ERROR_SUCCESS;
-    if (res != ERROR_SUCCESS)
-      return res;
+    if (result == ERROR_NO_MORE_ITEMS)
+      break;
+    if (result != ERROR_SUCCESS)
+      return result;
     keyNames.Add(keyName);
   }
+  return ERROR_SUCCESS;
 }
 
-
 LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
 {
   size_t numChars = 0;
+  
   unsigned i;
   
   for (i = 0; i < strings.Size(); i++)
@@ -435,11 +349,10 @@ LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
   for (i = 0; i < strings.Size(); i++)
   {
     const UString &s = strings[i];
-    const size_t size = s.Len() + 1;
+    size_t size = s.Len() + 1;
     wmemcpy(buffer + pos, s, size);
     pos += size;
   }
-  // if (pos != numChars) return E_FAIL;
   return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
 }
 
@@ -447,18 +360,20 @@ LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
 {
   strings.Clear();
   CByteBuffer buffer;
-  const LONG res = QueryValue_Binary(valueName, buffer);
+  UInt32 dataSize = 0;
+  LONG res = QueryValue(valueName, buffer, dataSize);
   if (res != ERROR_SUCCESS)
     return res;
-  const size_t dataSize = buffer.Size();
-  if (dataSize % sizeof(wchar_t))
-    return ERROR_INVALID_DATA;
-  const wchar_t *data = (const wchar_t *)(const void *)(const Byte  *)buffer;
-  const size_t numChars = dataSize / sizeof(wchar_t);
-  // we can check that all names are finished
-  // if (numChars != 0 && data[numChars - 1] != 0) return ERROR_INVALID_DATA;
+  if (dataSize > buffer.Size())
+    return E_FAIL;
+  if (dataSize % sizeof(wchar_t) != 0)
+    return E_FAIL;
+
+  const wchar_t *data = (const wchar_t *)(const Byte  *)buffer;
+  size_t numChars = dataSize / sizeof(wchar_t);
   size_t prev = 0;
   UString s;
+  
   for (size_t i = 0; i < numChars; i++)
   {
     if (data[i] == 0)
@@ -468,6 +383,7 @@ LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
       prev = i + 1;
     }
   }
+  
   return res;
 }
 

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

@@ -1,7 +1,7 @@
 // Windows/Registry.h
 
-#ifndef ZIP7_INC_WINDOWS_REGISTRY_H
-#define ZIP7_INC_WINDOWS_REGISTRY_H
+#ifndef __WINDOWS_REGISTRY_H
+#define __WINDOWS_REGISTRY_H
 
 #include "../Common/MyBuffer.h"
 #include "../Common/MyString.h"
@@ -14,13 +14,6 @@ LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
 class CKey
 {
   HKEY _object;
-
-  LONG QueryValueEx(LPCTSTR lpValueName, LPDWORD lpType,
-      LPBYTE lpData, LPDWORD lpcbData)
-  {
-    return RegQueryValueEx(_object, lpValueName, NULL, lpType, lpData, lpcbData);
-  }
-
 public:
   CKey(): _object(NULL) {}
   ~CKey() { Close(); }
@@ -29,14 +22,13 @@ public:
   void Attach(HKEY key) { _object = key; }
   HKEY Detach()
   {
-    const HKEY key = _object;
+    HKEY key = _object;
     _object = NULL;
     return key;
   }
 
   LONG Create(HKEY parentKey, LPCTSTR keyName,
-      LPTSTR keyClass = REG_NONE,
-      DWORD options = REG_OPTION_NON_VOLATILE,
+      LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
       REGSAM accessMask = KEY_ALL_ACCESS,
       LPSECURITY_ATTRIBUTES securityAttributes = NULL,
       LPDWORD disposition = NULL) throw();
@@ -48,18 +40,18 @@ public:
   LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
 
   LONG DeleteValue(LPCTSTR name) throw();
-#ifndef _UNICODE
+  #ifndef _UNICODE
   LONG DeleteValue(LPCWSTR name);
-#endif
+  #endif
 
   LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
   LONG SetValue(LPCTSTR valueName, bool value) throw();
   LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
   // LONG SetValue(LPCTSTR valueName, const CSysString &value);
-#ifndef _UNICODE
+  #ifndef _UNICODE
   LONG SetValue(LPCWSTR name, LPCWSTR value);
   // LONG SetValue(LPCWSTR name, const UString &value);
-#endif
+  #endif
 
   LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
 
@@ -68,25 +60,21 @@ public:
 
   LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
 
-  // GetValue_[type]_IfOk():
-  //   if (return_result == ERROR_SUCCESS), (value) variable was read from registry
-  //   if (return_result != ERROR_SUCCESS), (value) variable was not changed
-  LONG GetValue_UInt32_IfOk(LPCTSTR name, UInt32 &value) throw();
-  LONG GetValue_UInt64_IfOk(LPCTSTR name, UInt64 &value) throw();
-  LONG GetValue_bool_IfOk(LPCTSTR name, bool &value) throw();
-
-  // QueryValue():
-  //   if (return_result == ERROR_SUCCESS), (value) string was read from registry
-  //   if (return_result != ERROR_SUCCESS), (value) string was cleared
+  LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
+  LONG QueryValue(LPCTSTR name, bool &value) throw();
+  LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
   LONG QueryValue(LPCTSTR name, CSysString &value);
-#ifndef _UNICODE
+
+  LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
+  LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
+
+  #ifndef _UNICODE
+  LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
   LONG QueryValue(LPCWSTR name, UString &value);
-#endif
+  #endif
 
-  // QueryValue_Binary():
-  //   if (return_result == ERROR_SUCCESS), (value) buffer was read from registry (BINARY data)
-  //   if (return_result != ERROR_SUCCESS), (value) buffer was cleared
-  LONG QueryValue_Binary(LPCTSTR name, CByteBuffer &value);
+  LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
+  LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
 
   LONG EnumKeys(CSysStringVector &keyNames);
 };

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

@@ -25,10 +25,10 @@ static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
   do
   {
     size <<= 1;
-    len = ::LoadString(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+    len = ::LoadString(hInstance, resourceID, s.GetBuf(size - 1), size);
   }
   while (size - len <= 1);
-  s.ReleaseBuf_CalcLen((unsigned)len);
+  s.ReleaseBuf_CalcLen(len);
   return s;
 }
 
@@ -43,10 +43,10 @@ static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
   do
   {
     size <<= 1;
-    len = ::LoadStringW(hInstance, resourceID, s.GetBuf((unsigned)size - 1), size);
+    len = ::LoadStringW(hInstance, resourceID, s.GetBuf(size - 1), size);
   }
   while (size - len <= 1);
-  s.ReleaseBuf_CalcLen((unsigned)len);
+  s.ReleaseBuf_CalcLen(len);
 }
 
 // NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.

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

@@ -1,10 +1,9 @@
 // Windows/ResourceString.h
 
-#ifndef ZIP7_INC_WINDOWS_RESOURCE_STRING_H
-#define ZIP7_INC_WINDOWS_RESOURCE_STRING_H
+#ifndef __WINDOWS_RESOURCE_STRING_H
+#define __WINDOWS_RESOURCE_STRING_H
 
 #include "../Common/MyString.h"
-#include "../Common/MyWindows.h"
 
 namespace NWindows {