react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/CrcReg.cpp

@@ -11,44 +11,65 @@
 
 EXTERN_C_BEGIN
 
-EXTERN_C_END
+typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
 
-Z7_CLASS_IMP_COM_2(
-  CCrcHasher
-  , IHasher
-  , ICompressSetCoderProperties
-)
-  UInt32 _crc;
-  Z7_CRC_UPDATE_FUNC _updateFunc;
+UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
 
-  Z7_CLASS_NO_COPY(CCrcHasher)
+extern CRC_FUNC g_CrcUpdate;
+extern CRC_FUNC g_CrcUpdateT8;
+extern CRC_FUNC g_CrcUpdateT4;
 
+EXTERN_C_END
+
+class CCrcHasher:
+  public IHasher,
+  public ICompressSetCoderProperties,
+  public CMyUnknownImp
+{
+  UInt32 _crc;
+  CRC_FUNC _updateFunc;
+  Byte mtDummy[1 << 7];
+  
   bool SetFunctions(UInt32 tSize);
 public:
-  Byte _mtDummy[1 << 7];  // it's public to eliminate clang warning: unused private field
-
   CCrcHasher(): _crc(CRC_INIT_VAL) { SetFunctions(0); }
+
+  MY_UNKNOWN_IMP2(IHasher, ICompressSetCoderProperties)
+  INTERFACE_IHasher(;)
+  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
 };
 
 bool CCrcHasher::SetFunctions(UInt32 tSize)
 {
-  const Z7_CRC_UPDATE_FUNC f = z7_GetFunc_CrcUpdate(tSize);
-  if (!f)
+  _updateFunc = g_CrcUpdate;
+  
+  if (tSize == 1)
+    _updateFunc = CrcUpdateT1;
+  else if (tSize == 4)
+  {
+    if (g_CrcUpdateT4)
+      _updateFunc = g_CrcUpdateT4;
+    else
+      return false;
+  }
+  else if (tSize == 8)
   {
-    _updateFunc = CrcUpdate;
-    return false;
+    if (g_CrcUpdateT8)
+      _updateFunc = g_CrcUpdateT8;
+    else
+      return false;
   }
-  _updateFunc = f;
+  
   return true;
 }
 
-Z7_COM7F_IMF(CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
 {
   for (UInt32 i = 0; i < numProps; i++)
   {
+    const PROPVARIANT &prop = coderProps[i];
     if (propIDs[i] == NCoderPropID::kDefaultProp)
     {
-      const PROPVARIANT &prop = coderProps[i];
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
       if (!SetFunctions(prop.ulVal))
@@ -58,20 +79,20 @@ Z7_COM7F_IMF(CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVAR
   return S_OK;
 }
 
-Z7_COM7F_IMF2(void, CCrcHasher::Init())
+STDMETHODIMP_(void) CCrcHasher::Init() throw()
 {
   _crc = CRC_INIT_VAL;
 }
 
-Z7_COM7F_IMF2(void, CCrcHasher::Update(const void *data, UInt32 size))
+STDMETHODIMP_(void) CCrcHasher::Update(const void *data, UInt32 size) throw()
 {
-  _crc = _updateFunc(_crc, data, size);
+  _crc = _updateFunc(_crc, data, size, g_CrcTable);
 }
 
-Z7_COM7F_IMF2(void, CCrcHasher::Final(Byte *digest))
+STDMETHODIMP_(void) CCrcHasher::Final(Byte *digest) throw()
 {
-  const UInt32 val = CRC_GET_DIGEST(_crc);
-  SetUi32(digest, val)
+  UInt32 val = CRC_GET_DIGEST(_crc);
+  SetUi32(digest, val);
 }
 
 REGISTER_HASHER(CCrcHasher, 0x1, "CRC32", 4)

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/Defs.h

@@ -1,7 +1,7 @@
 // Common/Defs.h
 
-#ifndef ZIP7_INC_COMMON_DEFS_H
-#define ZIP7_INC_COMMON_DEFS_H
+#ifndef __COMMON_DEFS_H
+#define __COMMON_DEFS_H
 
 template <class T> inline T MyMin(T a, T b) { return a < b ? a : b; }
 template <class T> inline T MyMax(T a, T b) { return a > b ? a : b; }
@@ -10,7 +10,6 @@ template <class T> inline int MyCompare(T a, T b)
   { return a == b ? 0 : (a < b ? -1 : 1); }
 
 inline int BoolToInt(bool v) { return (v ? 1 : 0); }
-inline unsigned BoolToUInt(bool v) { return (v ? 1u : 0u); }
 inline bool IntToBool(int v) { return (v != 0); }
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/DynamicBuffer.h

@@ -1,11 +1,7 @@
 // Common/DynamicBuffer.h
 
-#ifndef ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
-#define ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
-
-#include <string.h>
-
-#include "MyTypes.h"
+#ifndef __COMMON_DYNAMIC_BUFFER_H
+#define __COMMON_DYNAMIC_BUFFER_H
 
 template <class T> class CDynamicBuffer
 {
@@ -38,19 +34,11 @@ template <class T> class CDynamicBuffer
   }
 
 public:
-  CDynamicBuffer(): _items(NULL), _size(0), _pos(0) {}
+  CDynamicBuffer(): _items(0), _size(0), _pos(0) {}
   // operator T *() { return _items; }
   operator const T *() const { return _items; }
   ~CDynamicBuffer() { delete []_items; }
 
-  void Free()
-  {
-    delete []_items;
-    _items = NULL;
-    _size = 0;
-    _pos = 0;
-  }
-
   T *GetCurPtrAndGrow(size_t addSize)
   {
     size_t rem = _size - _pos;
@@ -66,11 +54,11 @@ public:
     memcpy(GetCurPtrAndGrow(size), data, size * sizeof(T));
   }
 
-  size_t GetPos() const { return _pos; }
+  const size_t GetPos() const { return _pos; }
 
   // void Empty() { _pos = 0; }
 };
 
-typedef CDynamicBuffer<Byte> CByteDynamicBuffer;
+typedef CDynamicBuffer<unsigned char> CByteDynamicBuffer;
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/IntToString.cpp

@@ -7,133 +7,103 @@
 #include "IntToString.h"
 
 #define CONVERT_INT_TO_STR(charType, tempSize) \
-  if (val < 10) \
-    *s++ = (charType)('0' + (unsigned)val); \
-  else { \
-    Byte temp[tempSize]; \
-    size_t i = 0; \
-    do { \
-      temp[++i] = (Byte)('0' + (unsigned)(val % 10)); \
-      val /= 10; } \
-    while (val >= 10); \
-    *s++ = (charType)('0' + (unsigned)val); \
-    do { *s++ = (charType)temp[i]; } \
-    while (--i); \
-  } \
-  *s = 0; \
-  return s;
-
-char * ConvertUInt32ToString(UInt32 val, char *s) throw()
-{
-  CONVERT_INT_TO_STR(char, 16)
-}
-
-char * ConvertUInt64ToString(UInt64 val, char *s) throw()
-{
-  if (val <= (UInt32)0xFFFFFFFF)
-    return ConvertUInt32ToString((UInt32)val, s);
-  CONVERT_INT_TO_STR(char, 24)
-}
+  unsigned char temp[tempSize]; unsigned i = 0; \
+  while (val >= 10) { temp[i++] = (unsigned char)('0' + (unsigned)(val % 10)); val /= 10; } \
+  *s++ = (charType)('0' + (unsigned)val); \
+  while (i != 0) { i--; *s++ = temp[i]; } \
+  *s = 0;
 
-wchar_t * ConvertUInt32ToString(UInt32 val, wchar_t *s) throw()
+void ConvertUInt32ToString(UInt32 val, char *s) throw()
 {
-  CONVERT_INT_TO_STR(wchar_t, 16)
+  CONVERT_INT_TO_STR(char, 16);
 }
 
-wchar_t * ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
+void ConvertUInt64ToString(UInt64 val, char *s) throw()
 {
   if (val <= (UInt32)0xFFFFFFFF)
-    return ConvertUInt32ToString((UInt32)val, s);
-  CONVERT_INT_TO_STR(wchar_t, 24)
-}
-
-void ConvertInt64ToString(Int64 val, char *s) throw()
-{
-  if (val < 0)
-  {
-    *s++ = '-';
-    val = -val;
-  }
-  ConvertUInt64ToString((UInt64)val, s);
-}
-
-void ConvertInt64ToString(Int64 val, wchar_t *s) throw()
-{
-  if (val < 0)
   {
-    *s++ = L'-';
-    val = -val;
+    ConvertUInt32ToString((UInt32)val, s);
+    return;
   }
-  ConvertUInt64ToString((UInt64)val, s);
+  CONVERT_INT_TO_STR(char, 24);
 }
 
-
 void ConvertUInt64ToOct(UInt64 val, char *s) throw()
 {
+  UInt64 v = val;
+  unsigned i;
+  for (i = 1;; i++)
   {
-    UInt64 v = val;
-    do
-      s++;
-    while (v >>= 3);
+    v >>= 3;
+    if (v == 0)
+      break;
   }
-  *s = 0;
+  s[i] = 0;
   do
   {
-    const unsigned t = (unsigned)val & 7;
-    *--s = (char)('0' + t);
+    unsigned t = (unsigned)(val & 0x7);
+    val >>= 3;
+    s[--i] = (char)('0' + t);
   }
-  while (val >>= 3);
+  while (i);
 }
 
-MY_ALIGN(16) const char k_Hex_Upper[16] =
- { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };
-MY_ALIGN(16) const char k_Hex_Lower[16] =
- { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' };
+
+#define GET_HEX_CHAR(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
+
+static inline char GetHexChar(unsigned t) { return GET_HEX_CHAR(t); }
+
 
 void ConvertUInt32ToHex(UInt32 val, char *s) throw()
 {
+  UInt32 v = val;
+  unsigned i;
+  for (i = 1;; i++)
   {
-    UInt32 v = val;
-    do
-      s++;
-    while (v >>= 4);
+    v >>= 4;
+    if (v == 0)
+      break;
   }
-  *s = 0;
+  s[i] = 0;
   do
   {
-    const unsigned t = (unsigned)val & 0xF;
-    *--s = GET_HEX_CHAR_UPPER(t);
+    unsigned t = (unsigned)(val & 0xF);
+    val >>= 4;
+    s[--i] = GET_HEX_CHAR(t);
   }
-  while (val >>= 4);
+  while (i);
 }
 
+
 void ConvertUInt64ToHex(UInt64 val, char *s) throw()
 {
+  UInt64 v = val;
+  unsigned i;
+  for (i = 1;; i++)
   {
-    UInt64 v = val;
-    do
-      s++;
-    while (v >>= 4);
+    v >>= 4;
+    if (v == 0)
+      break;
   }
-  *s = 0;
+  s[i] = 0;
   do
   {
-    const unsigned t = (unsigned)val & 0xF;
-    *--s = GET_HEX_CHAR_UPPER(t);
+    unsigned t = (unsigned)(val & 0xF);
+    val >>= 4;
+    s[--i] = GET_HEX_CHAR(t);
   }
-  while (val >>= 4);
+  while (i);
 }
 
 void ConvertUInt32ToHex8Digits(UInt32 val, char *s) throw()
 {
   s[8] = 0;
-  int i = 7;
-  do
+  for (int i = 7; i >= 0; i--)
   {
-    { const unsigned t = (unsigned)val & 0xF;       s[i--] = GET_HEX_CHAR_UPPER(t); }
-    { const unsigned t = (Byte)val >> 4; val >>= 8; s[i--] = GET_HEX_CHAR_UPPER(t); }
+    unsigned t = val & 0xF;
+    val >>= 4;
+    s[i] = GET_HEX_CHAR(t);;
   }
-  while (i >= 0);
 }
 
 /*
@@ -142,74 +112,82 @@ void ConvertUInt32ToHex8Digits(UInt32 val, wchar_t *s)
   s[8] = 0;
   for (int i = 7; i >= 0; i--)
   {
-    const unsigned t = (unsigned)val & 0xF;
+    unsigned t = val & 0xF;
     val >>= 4;
-    s[i] = GET_HEX_CHAR(t);
+    s[i] = (wchar_t)(((t < 10) ? ('0' + t) : ('A' + (t - 10))));
   }
 }
 */
 
+void ConvertUInt32ToString(UInt32 val, wchar_t *s) throw()
+{
+  CONVERT_INT_TO_STR(wchar_t, 16);
+}
 
-MY_ALIGN(16) static const Byte k_Guid_Pos[] =
-  { 6,4,2,0, 11,9, 16,14, 19,21, 24,26,28,30,32,34 };
-
-char *RawLeGuidToString(const Byte *g, char *s) throw()
+void ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
 {
-  s[ 8] = '-';
-  s[13] = '-';
-  s[18] = '-';
-  s[23] = '-';
-  s[36] = 0;
-  for (unsigned i = 0; i < 16; i++)
+  if (val <= (UInt32)0xFFFFFFFF)
   {
-    char *s2 = s + k_Guid_Pos[i];
-    const unsigned v = g[i];
-    s2[0] = GET_HEX_CHAR_UPPER(v >> 4);
-    s2[1] = GET_HEX_CHAR_UPPER(v & 0xF);
+    ConvertUInt32ToString((UInt32)val, s);
+    return;
   }
-  return s + 36;
+  CONVERT_INT_TO_STR(wchar_t, 24);
 }
 
-char *RawLeGuidToString_Braced(const Byte *g, char *s) throw()
+void ConvertInt64ToString(Int64 val, char *s) throw()
 {
-  *s++ = '{';
-  s = RawLeGuidToString(g, s);
-  *s++ = '}';
-  *s = 0;
-  return s;
+  if (val < 0)
+  {
+    *s++ = '-';
+    val = -val;
+  }
+  ConvertUInt64ToString(val, s);
 }
 
-
-void ConvertDataToHex_Lower(char *dest, const Byte *src, size_t size) throw()
+void ConvertInt64ToString(Int64 val, wchar_t *s) throw()
 {
-  if (size)
+  if (val < 0)
   {
-    const Byte *lim = src + size;
-    do
-    {
-      const unsigned b = *src++;
-      dest[0] = GET_HEX_CHAR_LOWER(b >> 4);
-      dest[1] = GET_HEX_CHAR_LOWER(b & 0xF);
-      dest += 2;
-    }
-    while (src != lim);
+    *s++ = L'-';
+    val = -val;
   }
-  *dest = 0;
+  ConvertUInt64ToString(val, s);
 }
 
-void ConvertDataToHex_Upper(char *dest, const Byte *src, size_t size) throw()
+
+static void ConvertByteToHex2Digits(unsigned v, char *s) throw()
+{
+  s[0] = GetHexChar(v >> 4);
+  s[1] = GetHexChar(v & 0xF);
+}
+
+static void ConvertUInt16ToHex4Digits(UInt32 val, char *s) throw()
+{
+  ConvertByteToHex2Digits(val >> 8, s);
+  ConvertByteToHex2Digits(val & 0xFF, s + 2);
+}
+
+char *RawLeGuidToString(const Byte *g, char *s) throw()
 {
-  if (size)
+  ConvertUInt32ToHex8Digits(GetUi32(g   ),  s);  s += 8;  *s++ = '-';
+  ConvertUInt16ToHex4Digits(GetUi16(g + 4), s);  s += 4;  *s++ = '-';
+  ConvertUInt16ToHex4Digits(GetUi16(g + 6), s);  s += 4;  *s++ = '-';
+  for (unsigned i = 0; i < 8; i++)
   {
-    const Byte *lim = src + size;
-    do
-    {
-      const unsigned b = *src++;
-      dest[0] = GET_HEX_CHAR_UPPER(b >> 4);
-      dest[1] = GET_HEX_CHAR_UPPER(b & 0xF);
-      dest += 2;
-    }
-    while (src != lim);
+    if (i == 2)
+      *s++ = '-';
+    ConvertByteToHex2Digits(g[8 + i], s);
+    s += 2;
   }
-  *dest = 0;
+  *s = 0;
+  return s;
+}
+
+char *RawLeGuidToString_Braced(const Byte *g, char *s) throw()
+{
+  *s++ = '{';
+  s = RawLeGuidToString(g, s);
+  *s++ = '}';
+  *s = 0;
+  return s;
 }

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/IntToString.h

@@ -1,54 +1,28 @@
 // Common/IntToString.h
 
-#ifndef ZIP7_INC_COMMON_INT_TO_STRING_H
-#define ZIP7_INC_COMMON_INT_TO_STRING_H
+#ifndef __COMMON_INT_TO_STRING_H
+#define __COMMON_INT_TO_STRING_H
 
 #include "MyTypes.h"
 
-// return: the pointer to the "terminating" null character after written characters
+void ConvertUInt32ToString(UInt32 value, char *s) throw();
+void ConvertUInt64ToString(UInt64 value, char *s) throw();
 
-char * ConvertUInt32ToString(UInt32 value, char *s) throw();
-char * ConvertUInt64ToString(UInt64 value, char *s) throw();
-
-wchar_t * ConvertUInt32ToString(UInt32 value, wchar_t *s) throw();
-wchar_t * ConvertUInt64ToString(UInt64 value, wchar_t *s) throw();
-void ConvertInt64ToString(Int64 value, char *s) throw();
-void ConvertInt64ToString(Int64 value, wchar_t *s) throw();
+void ConvertUInt32ToString(UInt32 value, wchar_t *s) throw();
+void ConvertUInt64ToString(UInt64 value, wchar_t *s) throw();
 
 void ConvertUInt64ToOct(UInt64 value, char *s) throw();
 
-extern const char k_Hex_Upper[16];
-extern const char k_Hex_Lower[16];
-
-#define GET_HEX_CHAR_UPPER(t)  (k_Hex_Upper[t])
-#define GET_HEX_CHAR_LOWER(t)  (k_Hex_Lower[t])
-/*
-// #define GET_HEX_CHAR_UPPER(t) ((char)(((t < 10) ? ('0' + t) : ('A' + (t - 10)))))
-static inline unsigned GetHex_Lower(unsigned v)
-{
-  const unsigned v0 = v + '0';
-  v += 'a' - 10;
-  if (v < 'a')
-    v = v0;
-  return v;
-}
-static inline char GetHex_Upper(unsigned v)
-{
-  return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
-}
-*/
-
-
 void ConvertUInt32ToHex(UInt32 value, char *s) throw();
 void ConvertUInt64ToHex(UInt64 value, char *s) throw();
 void ConvertUInt32ToHex8Digits(UInt32 value, char *s) throw();
 // void ConvertUInt32ToHex8Digits(UInt32 value, wchar_t *s) throw();
 
+void ConvertInt64ToString(Int64 value, char *s) throw();
+void ConvertInt64ToString(Int64 value, wchar_t *s) throw();
+
 // use RawLeGuid only for RAW bytes that contain stored GUID as Little-endian.
 char *RawLeGuidToString(const Byte *guid, char *s) throw();
 char *RawLeGuidToString_Braced(const Byte *guid, char *s) throw();
 
-void ConvertDataToHex_Lower(char *dest, const Byte *src, size_t size) throw();
-void ConvertDataToHex_Upper(char *dest, const Byte *src, size_t size) throw();
-
 #endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/Lang.h

@@ -1,30 +1,23 @@
 // Common/Lang.h
 
-#ifndef ZIP7_INC_COMMON_LANG_H
-#define ZIP7_INC_COMMON_LANG_H
+#ifndef __COMMON_LANG_H
+#define __COMMON_LANG_H
 
 #include "MyString.h"
 
 class CLang
 {
   wchar_t *_text;
-
-  bool OpenFromString(const AString &s);
-public:
   CRecordVector<UInt32> _ids;
   CRecordVector<UInt32> _offsets;
-  UStringVector Comments;
 
-  CLang(): _text(NULL) {}
+  bool OpenFromString(const AString &s);
+public:
+  CLang(): _text(0) {}
   ~CLang() { Clear(); }
   bool Open(CFSTR fileName, const char *id);
   void Clear() throw();
-  bool IsEmpty() const { return _ids.IsEmpty(); }
   const wchar_t *Get(UInt32 id) const throw();
-  const wchar_t *Get_by_index(unsigned index) const throw()
-  {
-    return _text + (size_t)_offsets[index];
-  }
 };
 
 #endif