react-native-update 10.34.2 → 10.34.3

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

@@ -0,0 +1,330 @@
+// Common0.h
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#ifndef ZIP7_INC_COMMON0_H
+#define ZIP7_INC_COMMON0_H
+
+#include "../../C/Compiler.h"
+
+/*
+This file contains compiler related things for cpp files.
+This file is included to all cpp files in 7-Zip via "Common.h".
+Also this file is included in "IDecl.h" (that is included in interface files).
+So external modules can use 7-Zip interfaces without
+predefined macros defined in "Common.h".
+*/
+
+#ifdef _MSC_VER
+  #pragma warning(disable : 4710) // function not inlined
+  // 'CUncopyable::CUncopyable':
+  #pragma warning(disable : 4514) // unreferenced inline function has been removed
+  #if _MSC_VER < 1300
+    #pragma warning(disable : 4702) // unreachable code
+    #pragma warning(disable : 4714) // function marked as __forceinline not inlined
+    #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
+  #endif
+  #if _MSC_VER < 1400
+    #pragma warning(disable : 4511) // copy constructor could not be generated    // #pragma warning(disable : 4512) // assignment operator could not be generated
+    #pragma warning(disable : 4512) // assignment operator could not be generated
+  #endif
+  #if _MSC_VER > 1400 && _MSC_VER <= 1900
+    // #pragma warning(disable : 4996)
+       // strcat: This function or variable may be unsafe
+       // GetVersion was declared deprecated
+  #endif
+
+#if _MSC_VER > 1200
+// -Wall warnings
+
+#if _MSC_VER <= 1600
+#pragma warning(disable : 4917) // 'OLE_HANDLE' : a GUID can only be associated with a class, interface or namespace
+#endif
+
+// #pragma warning(disable : 4061) // enumerator '' in switch of enum '' is not explicitly handled by a case label
+// #pragma warning(disable : 4266) // no override available for virtual member function from base ''; function is hidden
+#pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+#pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+#if _MSC_VER >= 1600 && _MSC_VER < 1920
+#pragma warning(disable : 4571) // Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
+#endif
+#if _MSC_VER >= 1600
+#pragma warning(disable : 4365) // 'initializing' : conversion from 'int' to 'unsigned int', signed / unsigned mismatch
+#endif
+#if _MSC_VER < 1800
+// we disable the warning, if we don't use 'final' in class
+#pragma warning(disable : 4265) // class has virtual functions, but destructor is not virtual
+#endif
+
+#if _MSC_VER >= 1900
+#pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+#pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+#endif
+#if _MSC_VER >= 1912
+#pragma warning(disable : 5039) // pointer or reference to potentially throwing function passed to 'extern "C"' function under - EHc.Undefined behavior may occur if this function throws an exception.
+#endif
+#if _MSC_VER >= 1925
+// #pragma warning(disable : 5204) // 'ISequentialInStream' : class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
+#endif
+#if _MSC_VER >= 1934
+// #pragma warning(disable : 5264) // const variable is not used
+#endif
+
+#endif // _MSC_VER > 1200
+#endif // _MSC_VER
+
+
+#if defined(_MSC_VER) // && !defined(__clang__)
+#define Z7_DECLSPEC_NOTHROW   __declspec(nothrow)
+#elif defined(__clang__) || defined(__GNUC__)
+#define Z7_DECLSPEC_NOTHROW   __attribute__((nothrow))
+#else
+#define Z7_DECLSPEC_NOTHROW
+#endif
+
+/*
+#if defined (_MSC_VER) && _MSC_VER >= 1900 \
+    || defined(__clang__) && __clang_major__ >= 6 \
+    || defined(__GNUC__) && __GNUC__ >= 6
+  #define Z7_noexcept noexcept
+#else
+  #define Z7_noexcept throw()
+#endif
+*/
+
+
+#if defined(__clang__)
+
+#if /* defined(_WIN32) && */ __clang_major__ >= 16
+#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+
+#if __clang_major__ >= 4 && __clang_major__ < 12 && !defined(_WIN32)
+/*
+if compiled with new GCC libstdc++, GCC libstdc++ can use:
+13.2.0/include/c++/
+    <new> : #define _NEW
+    <stdlib.h> : #define _GLIBCXX_STDLIB_H 1
+*/
+#pragma GCC diagnostic ignored "-Wreserved-id-macro"
+#endif
+
+// noexcept, final, = delete
+#pragma GCC diagnostic ignored "-Wc++98-compat"
+#if __clang_major__ >= 4
+// throw() dynamic exception specifications are deprecated
+#pragma GCC diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+
+#if __clang_major__ <= 6 // check it
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wglobal-constructors"
+#pragma GCC diagnostic ignored "-Wexit-time-destructors"
+
+#if defined(Z7_LLVM_CLANG_VERSION) && __clang_major__ >= 18 // 18.1.0RC
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#endif
+// #pragma GCC diagnostic ignored "-Wunused-private-field"
+// #pragma GCC diagnostic ignored "-Wnonportable-system-include-path"
+// #pragma GCC diagnostic ignored "-Wsuggest-override"
+// #pragma GCC diagnostic ignored "-Wsign-conversion"
+// #pragma GCC diagnostic ignored "-Winconsistent-missing-override"
+// #pragma GCC diagnostic ignored "-Wsuggest-destructor-override"
+// #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-with-user-provided-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-dtor"
+// #ifndef _WIN32
+// #pragma GCC diagnostic ignored "-Wweak-vtables"
+// #endif
+/*
+#if   defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400) \
+   || defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30000)
+// enumeration values not explicitly handled in switch
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+*/
+#endif // __clang__
+
+
+#ifdef __GNUC__
+// #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
+
+/* There is BUG in MSVC 6.0 compiler for operator new[]:
+   It doesn't check overflow, when it calculates size in bytes for allocated array.
+   So we can use Z7_ARRAY_NEW macro instead of new[] operator. */
+
+#if defined(_MSC_VER) && (_MSC_VER == 1200) && !defined(_WIN64)
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[((size) > 0xFFFFFFFFu / sizeof(T)) ? 0xFFFFFFFFu / sizeof(T) : (size)];
+#else
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[size];
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8))
+  #define Z7_ATTR_NORETURN  __attribute__((noreturn))
+#elif (defined(__clang__) && (__clang_major__ >= 3))
+  #if __has_feature(cxx_attributes)
+    #define Z7_ATTR_NORETURN  [[noreturn]]
+  #else
+    #define Z7_ATTR_NORETURN  __attribute__((noreturn))
+  #endif
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1900))
+  #define Z7_ATTR_NORETURN  [[noreturn]]
+#else
+  #define Z7_ATTR_NORETURN
+#endif
+
+
+// final in "GCC 4.7.0"
+// In C++98 and C++03 code the alternative spelling __final can be used instead (this is a GCC extension.)
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || defined(_MSC_VER) && _MSC_VER >= 1800 \
+    || defined(__clang__) && __clang_major__ >= 4 \
+    /* || defined(__GNUC__) && __GNUC__ >= 9 */
+  #define Z7_final  final
+  #if defined(__clang__) && __cplusplus < 201103L
+    #pragma GCC diagnostic ignored "-Wc++11-extensions"
+  #endif
+#elif defined (__cplusplus) && __cplusplus >= 199711L \
+    && defined(__GNUC__) && __GNUC__ >= 4 && !defined(__clang__)
+  #define Z7_final __final
+#else
+  #define Z7_final
+  #if defined(__clang__) && __clang_major__ >= 4 \
+     || defined(__GNUC__) && __GNUC__ >= 4
+    #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+    #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+  #endif
+#endif
+
+#define Z7_class_final(c)  class c Z7_final
+
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+  #define Z7_CPP_IS_SUPPORTED_default
+  #define Z7_eq_delete  = delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c) c(const c& k) = default;
+#else
+  #define Z7_eq_delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c)
+#endif
+
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L) \
+    || defined(_MSC_VER) && (_MSC_VER >= 1400) /* && (_MSC_VER != 1600) */ \
+    || defined(__clang__) && __clang_major__ >= 4
+  #if defined(_MSC_VER) && (_MSC_VER == 1600) /* && (_MSC_VER != 1600) */
+    #pragma warning(disable : 4481) // nonstandard extension used: override specifier 'override'
+    #define Z7_DESTRUCTOR_override
+  #else
+    #define Z7_DESTRUCTOR_override  override
+  #endif
+  #define Z7_override  override
+#else
+  #define Z7_override
+  #define Z7_DESTRUCTOR_override
+#endif
+
+
+
+#define Z7_CLASS_NO_COPY(cls) \
+  private: \
+  cls(const cls &) Z7_eq_delete; \
+  cls &operator=(const cls &) Z7_eq_delete;
+
+class CUncopyable
+{
+protected:
+  CUncopyable() {} // allow constructor
+  // ~CUncopyable() {}
+  Z7_CLASS_NO_COPY(CUncopyable)
+};
+
+#define MY_UNCOPYABLE  :private CUncopyable
+// #define MY_UNCOPYABLE
+
+
+// typedef void (*Z7_void_Function)(void);
+
+#if defined(__clang__) || defined(__GNUC__)
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<Z7_void_Function>(e))
+#else
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<void*>(e))
+// #define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(e)
+#endif
+
+#define Z7_GET_PROC_ADDRESS(func_type, hmodule, func_name)  \
+    Z7_CAST_FUNC(func_type, GetProcAddress(hmodule, func_name))
+
+// || defined(__clang__)
+// || defined(__GNUC__)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define Z7_DECLSPEC_NOVTABLE __declspec(novtable)
+#else
+#define Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifdef __clang__
+#define Z7_PURE_INTERFACES_BEGIN \
+_Pragma("GCC diagnostic push") \
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+_Pragma("GCC diagnostic ignored \"-Wweak-vtables\"")
+#define Z7_PURE_INTERFACES_END \
+_Pragma("GCC diagnostic pop")
+#else
+#define Z7_PURE_INTERFACES_BEGIN
+#define Z7_PURE_INTERFACES_END
+#endif
+
+// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
+#include "NewHandler.h"
+
+/*
+// #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a)  Z7_ARRAY_SIZE(a)
+#endif
+*/
+
+#endif // ZIP7_INC_COMMON0_H
+
+
+
+// #define Z7_REDEFINE_NULL
+
+#if defined(Z7_REDEFINE_NULL) /* && (!defined(__clang__) || defined(_MSC_VER)) */
+
+// NULL is defined in <stddef.h>
+#include <stddef.h>
+#undef NULL
+
+#ifdef __cplusplus
+  #if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #define NULL  nullptr
+  #else
+    #define NULL  0
+  #endif
+#else
+  #define NULL  ((void *)0)
+#endif
+
+#else // Z7_REDEFINE_NULL
+
+#if defined(__clang__) && __clang_major__ >= 5
+#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#endif // Z7_REDEFINE_NULL
+
+// for precompiler:
+// #include "MyWindows.h"

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

@@ -0,0 +1,77 @@
+// CrcReg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/7zCrc.h"
+#include "../../C/CpuArch.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+EXTERN_C_BEGIN
+
+EXTERN_C_END
+
+Z7_CLASS_IMP_COM_2(
+  CCrcHasher
+  , IHasher
+  , ICompressSetCoderProperties
+)
+  UInt32 _crc;
+  Z7_CRC_UPDATE_FUNC _updateFunc;
+
+  Z7_CLASS_NO_COPY(CCrcHasher)
+
+  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); }
+};
+
+bool CCrcHasher::SetFunctions(UInt32 tSize)
+{
+  const Z7_CRC_UPDATE_FUNC f = z7_GetFunc_CrcUpdate(tSize);
+  if (!f)
+  {
+    _updateFunc = CrcUpdate;
+    return false;
+  }
+  _updateFunc = f;
+  return true;
+}
+
+Z7_COM7F_IMF(CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+{
+  for (UInt32 i = 0; i < numProps; i++)
+  {
+    if (propIDs[i] == NCoderPropID::kDefaultProp)
+    {
+      const PROPVARIANT &prop = coderProps[i];
+      if (prop.vt != VT_UI4)
+        return E_INVALIDARG;
+      if (!SetFunctions(prop.ulVal))
+        return E_NOTIMPL;
+    }
+  }
+  return S_OK;
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Init())
+{
+  _crc = CRC_INIT_VAL;
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Update(const void *data, UInt32 size))
+{
+  _crc = _updateFunc(_crc, data, size);
+}
+
+Z7_COM7F_IMF2(void, CCrcHasher::Final(Byte *digest))
+{
+  const 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

@@ -0,0 +1,16 @@
+// Common/Defs.h
+
+#ifndef ZIP7_INC_COMMON_DEFS_H
+#define ZIP7_INC_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; }
+
+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/DynLimBuf.cpp

@@ -0,0 +1,93 @@
+// Common/DynLimBuf.cpp
+
+#include "StdAfx.h"
+
+#include "DynLimBuf.h"
+#include "MyString.h"
+
+CDynLimBuf::CDynLimBuf(size_t limit) throw()
+{
+  _chars = NULL;
+  _pos = 0;
+  _size = 0;
+  _sizeLimit = limit;
+  _error = true;
+  unsigned size = 1 << 4;
+  if (size > limit)
+    size = (unsigned)limit;
+  _chars = (Byte *)MyAlloc(size);
+  if (_chars)
+  {
+    _size = size;
+    _error = false;
+  }
+}
+
+CDynLimBuf & CDynLimBuf::operator+=(char c) throw()
+{
+  if (_error)
+    return *this;
+  if (_size == _pos)
+  {
+    size_t n = _sizeLimit - _size;
+    if (n == 0)
+    {
+      _error = true;
+      return *this;
+    }
+    if (n > _size)
+      n = _size;
+
+    n += _pos;
+
+    Byte *newBuf = (Byte *)MyAlloc(n);
+    if (!newBuf)
+    {
+      _error = true;
+      return *this;
+    }
+    memcpy(newBuf, _chars, _pos);
+    MyFree(_chars);
+    _chars = newBuf;
+    _size = n;
+  }
+  _chars[_pos++] = (Byte)c;
+  return *this;
+}
+
+CDynLimBuf &CDynLimBuf::operator+=(const char *s) throw()
+{
+  if (_error)
+    return *this;
+  unsigned len = MyStringLen(s);
+  size_t rem = _sizeLimit - _pos;
+  if (rem < len)
+  {
+    len = (unsigned)rem;
+    _error = true;
+  }
+  if (_size - _pos < len)
+  {
+    size_t n = _pos + len;
+    if (n - _size < _size)
+    {
+      n = _sizeLimit;
+      if (n - _size > _size)
+        n = _size * 2;
+    }
+
+    Byte *newBuf = (Byte *)MyAlloc(n);
+    if (!newBuf)
+    {
+      _error = true;
+      return *this;
+    }
+    memcpy(newBuf, _chars, _pos);
+    MyFree(_chars);
+    _chars = newBuf;
+    _size = n;
+  }
+  memcpy(_chars + _pos, s, len);
+  _pos += len;
+  return *this;
+}

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

@@ -0,0 +1,41 @@
+// Common/DynLimBuf.h
+
+#ifndef ZIP7_INC_COMMON_DYN_LIM_BUF_H
+#define ZIP7_INC_COMMON_DYN_LIM_BUF_H
+
+#include <string.h>
+
+#include "../../C/Alloc.h"
+
+#include "MyString.h"
+
+class CDynLimBuf
+{
+  Byte *_chars;
+  size_t _pos;
+  size_t _size;
+  size_t _sizeLimit;
+  bool _error;
+
+  CDynLimBuf(const CDynLimBuf &s);
+
+  // ---------- forbidden functions ----------
+  CDynLimBuf &operator+=(wchar_t c);
+
+public:
+  CDynLimBuf(size_t limit) throw();
+  ~CDynLimBuf() { MyFree(_chars); }
+
+  size_t Len() const { return _pos; }
+  bool IsError() const { return _error; }
+  void Empty() { _pos = 0; _error = false; }
+
+  operator const Byte *() const { return _chars; }
+  // const char *Ptr() const { return _chars; }
+
+  CDynLimBuf &operator+=(char c) throw();
+  CDynLimBuf &operator+=(const char *s) throw();
+};
+
+
+#endif

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

@@ -0,0 +1,76 @@
+// Common/DynamicBuffer.h
+
+#ifndef ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+#define ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+
+#include <string.h>
+
+#include "MyTypes.h"
+
+template <class T> class CDynamicBuffer
+{
+  T *_items;
+  size_t _size;
+  size_t _pos;
+
+  CDynamicBuffer(const CDynamicBuffer &buffer);
+  void operator=(const CDynamicBuffer &buffer);
+
+  void Grow(size_t size)
+  {
+    size_t delta = _size >= 64 ? _size : 64;
+    if (delta < size)
+      delta = size;
+    size_t newCap = _size + delta;
+    if (newCap < delta)
+    {
+      newCap = _size + size;
+      if (newCap < size)
+        throw 20120116;
+    }
+
+    T *newBuffer = new T[newCap];
+    if (_pos != 0)
+      memcpy(newBuffer, _items, _pos * sizeof(T));
+    delete []_items;
+    _items = newBuffer;
+    _size = newCap;
+  }
+
+public:
+  CDynamicBuffer(): _items(NULL), _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;
+    if (rem < addSize)
+      Grow(addSize - rem);
+    T *res = _items + _pos;
+    _pos += addSize;
+    return res;
+  }
+
+  void AddData(const T *data, size_t size)
+  {
+    memcpy(GetCurPtrAndGrow(size), data, size * sizeof(T));
+  }
+
+  size_t GetPos() const { return _pos; }
+
+  // void Empty() { _pos = 0; }
+};
+
+typedef CDynamicBuffer<Byte> CByteDynamicBuffer;
+
+#endif