react-native-update 8.5.5 → 8.5.6

package/harmony/src/main/cpp/lzma/CPP/Windows/PropVariant.cpp

@@ -1,347 +0,0 @@
-// Windows/PropVariant.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/Defs.h"
-
-#include "PropVariant.h"
-
-namespace NWindows {
-namespace NCOM {
-
-BSTR AllocBstrFromAscii(const char *s) throw()
-{
-  if (!s)
-    return NULL;
-  UINT len = (UINT)strlen(s);
-  BSTR p = ::SysAllocStringLen(NULL, len);
-  if (p)
-  {
-    for (UINT i = 0; i <= len; i++)
-      p[i] = (Byte)s[i];
-  }
-  return p;
-}
-
-HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
-{
-  p->bstrVal = ::SysAllocStringLen(NULL, numChars);
-  if (!p->bstrVal)
-  {
-    p->vt = VT_ERROR;
-    p->scode = E_OUTOFMEMORY;
-    return E_OUTOFMEMORY;
-  }
-  p->vt = VT_BSTR;
-  return S_OK;
-}
-
-HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
-{
-  p->bstrVal = AllocBstrFromAscii(s);
-  if (p->bstrVal)
-  {
-    p->vt = VT_BSTR;
-    return S_OK;
-  }
-  p->vt = VT_ERROR;
-  p->scode = E_OUTOFMEMORY;
-  return E_OUTOFMEMORY;
-}
-
-CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
-{
-  vt = VT_EMPTY;
-  InternalCopy(&varSrc);
-}
-
-CPropVariant::CPropVariant(const CPropVariant &varSrc)
-{
-  vt = VT_EMPTY;
-  InternalCopy(&varSrc);
-}
-
-CPropVariant::CPropVariant(BSTR bstrSrc)
-{
-  vt = VT_EMPTY;
-  *this = bstrSrc;
-}
-
-CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
-{
-  vt = VT_EMPTY;
-  *this = lpszSrc;
-}
-
-CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
-{
-  InternalCopy(&varSrc);
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
-{
-  InternalCopy(&varSrc);
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
-{
-  *this = (LPCOLESTR)bstrSrc;
-  return *this;
-}
-
-static const char * const kMemException = "out of memory";
-
-CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
-{
-  InternalClear();
-  vt = VT_BSTR;
-  wReserved1 = 0;
-  bstrVal = ::SysAllocString(lpszSrc);
-  if (!bstrVal && lpszSrc)
-  {
-    throw kMemException;
-    // vt = VT_ERROR;
-    // scode = E_OUTOFMEMORY;
-  }
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const UString &s)
-{
-  InternalClear();
-  vt = VT_BSTR;
-  wReserved1 = 0;
-  bstrVal = ::SysAllocStringLen(s, s.Len());
-  if (!bstrVal)
-    throw kMemException;
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const UString2 &s)
-{
-  /*
-  if (s.IsEmpty())
-    *this = L"";
-  else
-  */
-  {
-    InternalClear();
-    vt = VT_BSTR;
-    wReserved1 = 0;
-    bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
-    if (!bstrVal)
-      throw kMemException;
-    /* SysAllocStringLen probably appends a null-terminating character for NULL string.
-       But it doesn't specified in MSDN.
-       But we suppose that it works
-
-    if (!s.GetRawPtr())
-    {
-      *bstrVal = 0;
-    }
-    */
-
-    /* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
-                         pointers to this function causes  an unexpected termination of the application.
-       Is it safe? Maybe we must chamnge the code for that case ? */
-  }
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(const char *s)
-{
-  InternalClear();
-  vt = VT_BSTR;
-  wReserved1 = 0;
-  bstrVal = AllocBstrFromAscii(s);
-  if (!bstrVal)
-  {
-    throw kMemException;
-    // vt = VT_ERROR;
-    // scode = E_OUTOFMEMORY;
-  }
-  return *this;
-}
-
-CPropVariant& CPropVariant::operator=(bool bSrc) throw()
-{
-  if (vt != VT_BOOL)
-  {
-    InternalClear();
-    vt = VT_BOOL;
-  }
-  boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
-  return *this;
-}
-
-BSTR CPropVariant::AllocBstr(unsigned numChars)
-{
-  if (vt != VT_EMPTY)
-    InternalClear();
-  vt = VT_BSTR;
-  wReserved1 = 0;
-  bstrVal = ::SysAllocStringLen(NULL, numChars);
-  if (!bstrVal)
-  {
-    throw kMemException;
-    // vt = VT_ERROR;
-    // scode = E_OUTOFMEMORY;
-  }
-  return bstrVal;
-}
-
-#define SET_PROP_FUNC(type, id, dest) \
-  CPropVariant& CPropVariant::operator=(type value) throw() \
-  { if (vt != id) { InternalClear(); vt = id; } \
-    dest = value; return *this; }
-
-SET_PROP_FUNC(Byte, VT_UI1, bVal)
-// SET_PROP_FUNC(Int16, VT_I2, iVal)
-SET_PROP_FUNC(Int32, VT_I4, lVal)
-SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
-SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
-SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
-SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
-
-HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
-{
-  switch (prop->vt)
-  {
-    case VT_EMPTY:
-    case VT_UI1:
-    case VT_I1:
-    case VT_I2:
-    case VT_UI2:
-    case VT_BOOL:
-    case VT_I4:
-    case VT_UI4:
-    case VT_R4:
-    case VT_INT:
-    case VT_UINT:
-    case VT_ERROR:
-    case VT_FILETIME:
-    case VT_UI8:
-    case VT_R8:
-    case VT_CY:
-    case VT_DATE:
-      prop->vt = VT_EMPTY;
-      prop->wReserved1 = 0;
-      prop->wReserved2 = 0;
-      prop->wReserved3 = 0;
-      prop->uhVal.QuadPart = 0;
-      return S_OK;
-  }
-  return ::VariantClear((VARIANTARG *)prop);
-  // return ::PropVariantClear(prop);
-  // PropVariantClear can clear VT_BLOB.
-}
-
-HRESULT CPropVariant::Clear() throw()
-{
-  if (vt == VT_EMPTY)
-    return S_OK;
-  return PropVariant_Clear(this);
-}
-
-HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
-{
-  ::VariantClear((tagVARIANT *)this);
-  switch (pSrc->vt)
-  {
-    case VT_UI1:
-    case VT_I1:
-    case VT_I2:
-    case VT_UI2:
-    case VT_BOOL:
-    case VT_I4:
-    case VT_UI4:
-    case VT_R4:
-    case VT_INT:
-    case VT_UINT:
-    case VT_ERROR:
-    case VT_FILETIME:
-    case VT_UI8:
-    case VT_R8:
-    case VT_CY:
-    case VT_DATE:
-      memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
-      return S_OK;
-  }
-  return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc));
-}
-
-
-HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
-{
-  HRESULT hr = Clear();
-  if (FAILED(hr))
-    return hr;
-  memcpy(this, pSrc, sizeof(PROPVARIANT));
-  pSrc->vt = VT_EMPTY;
-  return S_OK;
-}
-
-HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
-{
-  if (pDest->vt != VT_EMPTY)
-  {
-    HRESULT hr = PropVariant_Clear(pDest);
-    if (FAILED(hr))
-      return hr;
-  }
-  memcpy(pDest, this, sizeof(PROPVARIANT));
-  vt = VT_EMPTY;
-  return S_OK;
-}
-
-HRESULT CPropVariant::InternalClear() throw()
-{
-  if (vt == VT_EMPTY)
-    return S_OK;
-  HRESULT hr = Clear();
-  if (FAILED(hr))
-  {
-    vt = VT_ERROR;
-    scode = hr;
-  }
-  return hr;
-}
-
-void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
-{
-  HRESULT hr = Copy(pSrc);
-  if (FAILED(hr))
-  {
-    if (hr == E_OUTOFMEMORY)
-      throw kMemException;
-    vt = VT_ERROR;
-    scode = hr;
-  }
-}
-
-int CPropVariant::Compare(const CPropVariant &a) throw()
-{
-  if (vt != a.vt)
-    return MyCompare(vt, a.vt);
-  switch (vt)
-  {
-    case VT_EMPTY: return 0;
-    // case VT_I1: return MyCompare(cVal, a.cVal);
-    case VT_UI1: return MyCompare(bVal, a.bVal);
-    case VT_I2: return MyCompare(iVal, a.iVal);
-    case VT_UI2: return MyCompare(uiVal, a.uiVal);
-    case VT_I4: return MyCompare(lVal, a.lVal);
-    case VT_UI4: return MyCompare(ulVal, a.ulVal);
-    // case VT_UINT: return MyCompare(uintVal, a.uintVal);
-    case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
-    case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
-    case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
-    case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime);
-    case VT_BSTR: return 0; // Not implemented
-    default: return 0;
-  }
-}
-
-}}

package/harmony/src/main/cpp/lzma/CPP/Windows/PropVariant.h

@@ -1,114 +0,0 @@
-// Windows/PropVariant.h
-
-#ifndef __WINDOWS_PROP_VARIANT_H
-#define __WINDOWS_PROP_VARIANT_H
-
-#include "../Common/MyTypes.h"
-#include "../Common/MyWindows.h"
-#include "../Common/MyString.h"
-
-namespace NWindows {
-namespace NCOM {
-
-BSTR AllocBstrFromAscii(const char *s) throw();
-
-HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
-
-HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
-HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
-
-inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
-{
-  p->vt = VT_UI4;
-  p->ulVal = v;
-}
-
-inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
-{
-  p->vt = VT_UI8;
-  p->uhVal.QuadPart = v;
-}
-
-inline void PropVarEm_Set_FileTime64(PROPVARIANT *p, UInt64 v) throw()
-{
-  p->vt = VT_FILETIME;
-  p->filetime.dwLowDateTime = (DWORD)v;
-  p->filetime.dwHighDateTime = (DWORD)(v >> 32);
-}
-
-inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
-{
-  p->vt = VT_BOOL;
-  p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
-}
-
-
-class CPropVariant : public tagPROPVARIANT
-{
-public:
-  CPropVariant()
-  {
-    vt = VT_EMPTY;
-    wReserved1 = 0;
-    // wReserved2 = 0;
-    // wReserved3 = 0;
-    // uhVal.QuadPart = 0;
-    bstrVal = 0;
-  }
-  ~CPropVariant() throw() { 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; }
-
-private:
-  CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
-  CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
-
-public:
-  CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
-  CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
-  CPropVariant(Int64 value) { vt = VT_I8; wReserved1 = 0; hVal.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 UString &s);
-  CPropVariant& operator=(const UString2 &s);
-  CPropVariant& operator=(const char *s);
-  CPropVariant& operator=(const AString &s)
-    { return (*this)=(const char *)s; }
-  
-  CPropVariant& operator=(bool bSrc) throw();
-  CPropVariant& operator=(Byte value) throw();
-  
-private:
-  CPropVariant& operator=(Int16 value) throw();
-
-public:
-  CPropVariant& operator=(Int32 value) throw();
-  CPropVariant& operator=(UInt32 value) throw();
-  CPropVariant& operator=(UInt64 value) throw();
-  CPropVariant& operator=(Int64 value) throw();
-  CPropVariant& operator=(const FILETIME &value) throw();
-
-  BSTR AllocBstr(unsigned numChars);
-
-  HRESULT Clear() throw();
-  HRESULT Copy(const PROPVARIANT *pSrc) throw();
-  HRESULT Attach(PROPVARIANT *pSrc) throw();
-  HRESULT Detach(PROPVARIANT *pDest) throw();
-
-  HRESULT InternalClear() throw();
-  void InternalCopy(const PROPVARIANT *pSrc);
-
-  int Compare(const CPropVariant &a) throw();
-};
-
-}}
-
-#endif

package/harmony/src/main/cpp/lzma/CPP/Windows/PropVariantConv.cpp

@@ -1,138 +0,0 @@
-// PropVariantConvert.cpp
-
-#include "StdAfx.h"
-
-#include "../Common/IntToString.h"
-
-#include "Defs.h"
-#include "PropVariantConv.h"
-
-#define UINT_TO_STR_2(c, val) { s[0] = (c); s[1] = (char)('0' + (val) / 10); s[2] = (char)('0' + (val) % 10); s += 3; }
-
-bool ConvertUtcFileTimeToString(const FILETIME &utc, char *s, int level) throw()
-{
-  *s = 0;
-  FILETIME ft;
-  if (!FileTimeToLocalFileTime(&utc, &ft))
-    return false;
-
-  SYSTEMTIME st;
-  if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
-    return false;
-
-  {
-    unsigned val = st.wYear;
-    if (val >= 10000)
-    {
-      *s++ = (char)('0' + val / 10000);
-      val %= 10000;
-    }
-    s[3] = (char)('0' + val % 10); val /= 10;
-    s[2] = (char)('0' + val % 10); val /= 10;
-    s[1] = (char)('0' + val % 10);
-    s[0] = (char)('0' + val / 10);
-    s += 4;
-  }
-  UINT_TO_STR_2('-', st.wMonth);
-  UINT_TO_STR_2('-', st.wDay);
-  
-  if (level > kTimestampPrintLevel_DAY)
-  {
-    UINT_TO_STR_2(' ', st.wHour);
-    UINT_TO_STR_2(':', st.wMinute);
-    
-    if (level >= kTimestampPrintLevel_SEC)
-    {
-      UINT_TO_STR_2(':', st.wSecond);
-
-      if (level > kTimestampPrintLevel_SEC)
-      {
-        *s++ = '.';
-        /*
-        {
-          unsigned val = st.wMilliseconds;
-          s[2] = (char)('0' + val % 10); val /= 10;
-          s[1] = (char)('0' + val % 10);
-          s[0] = (char)('0' + val / 10);
-          s += 3;
-        }
-        *s++ = ' ';
-        */
-        
-        {
-          unsigned numDigits = 7;
-          UInt32 val = (UInt32)((((UInt64)ft.dwHighDateTime << 32) + ft.dwLowDateTime) % 10000000);
-          for (unsigned i = numDigits; i != 0;)
-          {
-            i--;
-            s[i] = (char)('0' + val % 10); val /= 10;
-          }
-          if (numDigits > (unsigned)level)
-            numDigits = (unsigned)level;
-          s += numDigits;
-        }
-      }
-    }
-  }
-  
-  *s = 0;
-  return true;
-}
-
-
-bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *dest, int level) throw()
-{
-  char s[32];
-  bool res = ConvertUtcFileTimeToString(ft, s, level);
-  for (unsigned i = 0;; i++)
-  {
-    unsigned char c = s[i];
-    dest[i] = c;
-    if (c == 0)
-      break;
-  }
-  return res;
-}
-
-
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw()
-{
-  *dest = 0;
-  switch (prop.vt)
-  {
-    case VT_EMPTY: return;
-    case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
-    case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
-    case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
-    case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
-    case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
-    case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
-    // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
-    case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
-    case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
-    case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
-    case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? '+' : '-'; dest[1] = 0; return;
-    default: dest[0] = '?'; dest[1] = ':'; ConvertUInt64ToString(prop.vt, dest + 2);
-  }
-}
-
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw()
-{
-  *dest = 0;
-  switch (prop.vt)
-  {
-    case VT_EMPTY: return;
-    case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
-    case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
-    case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
-    case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
-    case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
-    case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
-    // case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
-    case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
-    case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
-    case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
-    case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? (wchar_t)'+' : (wchar_t)'-'; dest[1] = 0; return;
-    default: dest[0] = '?'; dest[1] = ':'; ConvertUInt32ToString(prop.vt, dest + 2);
-  }
-}

package/harmony/src/main/cpp/lzma/CPP/Windows/PropVariantConv.h

@@ -1,37 +0,0 @@
-// Windows/PropVariantConv.h
-
-#ifndef __PROP_VARIANT_CONV_H
-#define __PROP_VARIANT_CONV_H
-
-#include "../Common/MyTypes.h"
-
-// provide at least 32 bytes for buffer including zero-end
-
-#define kTimestampPrintLevel_DAY -3
-// #define kTimestampPrintLevel_HOUR -2
-#define kTimestampPrintLevel_MIN -1
-#define kTimestampPrintLevel_SEC 0
-#define kTimestampPrintLevel_NTFS 7
-
-bool ConvertUtcFileTimeToString(const FILETIME &ft, char *s, int level = kTimestampPrintLevel_SEC) throw();
-bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
-
-// provide at least 32 bytes for buffer including zero-end
-// don't send VT_BSTR to these functions
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw();
-void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw();
-
-inline bool ConvertPropVariantToUInt64(const PROPVARIANT &prop, UInt64 &value)
-{
-  switch (prop.vt)
-  {
-    case VT_UI8: value = (UInt64)prop.uhVal.QuadPart; return true;
-    case VT_UI4: value = prop.ulVal; return true;
-    case VT_UI2: value = prop.uiVal; return true;
-    case VT_UI1: value = prop.bVal; return true;
-    case VT_EMPTY: return false;
-    default: throw 151199;
-  }
-}
-
-#endif