react-native-update 10.34.3 → 10.34.5

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

@@ -10,23 +10,21 @@
 
 #ifndef DEBUG_MEMORY_LEAK
 
-#ifdef Z7_REDEFINE_OPERATOR_NEW
+#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
 
 /*
 void * my_new(size_t size)
 {
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
-  if (size == 0)
-    size = 1;
   void *p = ::malloc(size);
-  if (!p)
+  if (p == 0)
     throw CNewException();
   return p;
 }
 
 void my_delete(void *p) throw()
 {
-  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
   ::free(p);
 }
 
@@ -46,64 +44,23 @@ __cdecl
 #endif
 operator new(size_t size)
 {
-  /* by C++ specification:
-       if (size == 0), operator new(size) returns non_NULL pointer.
-     If (operator new(0) returns NULL), it's out of specification.
-       but some calling code can work correctly even in this case too. */
-  // if (size == 0) return NULL; // for debug only. don't use it
-
-  /* malloc(0) returns non_NULL in main compilers, as we need here.
-     But specification also allows malloc(0) to return NULL.
-     So we change (size=0) to (size=1) here to get real non_NULL pointer */
-  if (size == 0)
-    size = 1;
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
-  // void *p = ::MyAlloc(size);  // note: MyAlloc(0) returns NULL
   void *p = ::malloc(size);
-  if (!p)
+  if (p == 0)
     throw CNewException();
   return p;
 }
 
-
-#if defined(_MSC_VER) && _MSC_VER == 1600
-// vs2010 has no throw() by default ?
-#pragma warning(push)
-#pragma warning(disable : 4986) // 'operator delete': exception specification does not match previous declaration
-#endif
-
 void
 #ifdef _MSC_VER
 __cdecl
 #endif
 operator delete(void *p) throw()
 {
-  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
-  // MyFree(p);
+  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
   ::free(p);
 }
 
-/* we define operator delete(void *p, size_t n) because
-   vs2022 compiler uses delete(void *p, size_t n), and
-   we want to mix files from different compilers:
-     - old vc6 linker
-     - old vc6 complier
-     - new vs2022 complier
-*/
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t n) throw()
-{
-  UNUSED_VAR(n)
-  ::free(p);
-}
-
-#if defined(_MSC_VER) && _MSC_VER == 1600
-#pragma warning(pop)
-#endif
-
 /*
 void *
 #ifdef _MSC_VER
@@ -112,10 +69,8 @@ __cdecl
 operator new[](size_t size)
 {
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
-  if (size == 0)
-    size = 1;
   void *p = ::malloc(size);
-  if (!p)
+  if (p == 0)
     throw CNewException();
   return p;
 }
@@ -126,7 +81,7 @@ __cdecl
 #endif
 operator delete[](void *p) throw()
 {
-  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
   ::free(p);
 }
 */
@@ -138,10 +93,25 @@ operator delete[](void *p) throw()
 #include <stdio.h>
 
 // #pragma init_seg(lib)
-/*
 const int kDebugSize = 1000000;
 static void *a[kDebugSize];
-static int g_index = 0;
+static int index = 0;
+
+static int numAllocs = 0;
+void * __cdecl operator new(size_t size)
+{
+  numAllocs++;
+  void *p = HeapAlloc(GetProcessHeap(), 0, size);
+  if (index < kDebugSize)
+  {
+    a[index] = p;
+    index++;
+  }
+  if (p == 0)
+    throw CNewException();
+  printf("Alloc %6d, size = %8u\n", numAllocs, (unsigned)size);
+  return p;
+}
 
 class CC
 {
@@ -153,174 +123,27 @@ public:
   }
   ~CC()
   {
-    printf("\nDestructor: %d\n", numAllocs);
     for (int i = 0; i < kDebugSize; i++)
       if (a[i] != 0)
         return;
   }
 } g_CC;
-*/
 
-#ifdef _WIN32
-static bool wasInit = false;
-static CRITICAL_SECTION cs;
-#endif
-
-static int numAllocs = 0;
 
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new(size_t size)
+void __cdecl operator delete(void *p)
 {
- #ifdef _WIN32
-  if (!wasInit)
-  {
-    InitializeCriticalSection(&cs);
-    wasInit = true;
-  }
-  EnterCriticalSection(&cs);
-
-  numAllocs++;
-  int loc = numAllocs;
-  void *p = HeapAlloc(GetProcessHeap(), 0, size);
-  /*
-  if (g_index < kDebugSize)
-  {
-    a[g_index] = p;
-    g_index++;
-  }
-  */
-  printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
-  LeaveCriticalSection(&cs);
-  if (!p)
-    throw CNewException();
-  return p;
- #else
-  numAllocs++;
-  int loc = numAllocs;
-  if (size == 0)
-    size = 1;
-  void *p = malloc(size);
-  /*
-  if (g_index < kDebugSize)
-  {
-    a[g_index] = p;
-    g_index++;
-  }
-  */
-  printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
-  if (!p)
-    throw CNewException();
-  return p;
- #endif
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p) throw()
-{
-  if (!p)
+  if (p == 0)
     return;
- #ifdef _WIN32
-  EnterCriticalSection(&cs);
   /*
-  for (int i = 0; i < g_index; i++)
+  for (int i = 0; i < index; i++)
     if (a[i] == p)
       a[i] = 0;
   */
   HeapFree(GetProcessHeap(), 0, p);
-  // if (numAllocs == 0) numAllocs = numAllocs; // ERROR
-  numAllocs--;
-  // if (numAllocs == 0) numAllocs = numAllocs; // OK: all objects were deleted
-  printf("Free %d\n", numAllocs);
-  LeaveCriticalSection(&cs);
- #else
-  free(p);
   numAllocs--;
   printf("Free %d\n", numAllocs);
- #endif
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t n) throw();
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t n) throw()
-{
-  UNUSED_VAR(n)
-  printf("delete_WITH_SIZE=%u, ptr = %p\n", (unsigned)n, p);
-  operator delete(p);
-}
-
-/*
-void *
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator new[](size_t size)
-{
-  printf("operator_new[] : ");
-  return operator new(size);
 }
 
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t sz) throw();
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t sz) throw()
-{
-  if (!p)
-    return;
-  printf("operator_delete_size : size=%d  : ", (unsigned)sz);
-  operator delete(p);
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete[](void *p) throw()
-{
-  if (!p)
-    return;
-  printf("operator_delete[] : ");
-  operator delete(p);
-}
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete[](void *p, size_t sz) throw();
-
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete[](void *p, size_t sz) throw()
-{
-  if (!p)
-    return;
-  printf("operator_delete_size[] : size=%d  : ", (unsigned)sz);
-  operator delete(p);
-}
-*/
-
 #endif
 
 /*

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

@@ -1,7 +1,7 @@
 // Common/NewHandler.h
 
-#ifndef ZIP7_INC_COMMON_NEW_HANDLER_H
-#define ZIP7_INC_COMMON_NEW_HANDLER_H
+#ifndef __COMMON_NEW_HANDLER_H
+#define __COMMON_NEW_HANDLER_H
 
 /*
 NewHandler.h and NewHandler.cpp allows to solve problem with compilers that
@@ -10,16 +10,6 @@ don't throw exception in operator new().
 This file must be included before any code that uses operators new() or delete()
 and you must compile and link "NewHandler.cpp", if you use some old MSVC compiler.
 
-DOCs:
-  Since ISO C++98, operator new throws std::bad_alloc when memory allocation fails.
-  MSVC 6.0 returned a null pointer on an allocation failure.
-  Beginning in VS2002, operator new conforms to the standard and throws on failure.
-
-  By default, the compiler also generates defensive null checks to prevent
-  these older-style allocators from causing an immediate crash on failure.
-  The /Zc:throwingNew option tells the compiler to leave out these null checks,
-  on the assumption that all linked memory allocators conform to the standard.
-
 The operator new() in some MSVC versions doesn't throw exception std::bad_alloc.
 MSVC 6.0 (_MSC_VER == 1200) doesn't throw exception.
 The code produced by some another MSVC compilers also can be linked
@@ -46,13 +36,13 @@ void my_delete(void *p) throw();
 #endif
 
 
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
   // If you want to use default operator new(), you can disable the following line
-  #define Z7_REDEFINE_OPERATOR_NEW
+  #define _7ZIP_REDEFINE_OPERATOR_NEW
 #endif
 
 
-#ifdef Z7_REDEFINE_OPERATOR_NEW
+#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
 
 // std::bad_alloc can require additional DLL dependency.
 // So we don't define CNewException as std::bad_alloc here.
@@ -65,35 +55,12 @@ __cdecl
 #endif
 operator new(size_t size);
 
-/*
-#if 0 && defined(_MSC_VER) && _MSC_VER == 1600
-  #define Z7_OPERATOR_DELETE_SPEC_THROW0
-#else
-  #define Z7_OPERATOR_DELETE_SPEC_THROW0 throw()
-#endif
-*/
-#if defined(_MSC_VER) && _MSC_VER == 1600
-#pragma warning(push)
-#pragma warning(disable : 4986) // 'operator delete': exception specification does not match previous declaration
-#endif
-
 void
 #ifdef _MSC_VER
 __cdecl
 #endif
 operator delete(void *p) throw();
 
-void
-#ifdef _MSC_VER
-__cdecl
-#endif
-operator delete(void *p, size_t n) throw();
-
-#if defined(_MSC_VER) && _MSC_VER == 1600
-#pragma warning(pop)
-#endif
-
-
 #else
 
 #include <new>

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

@@ -4,64 +4,37 @@
 
 #include "../../C/Sha256.h"
 
-#include "../Common/MyBuffer2.h"
 #include "../Common/MyCom.h"
 
 #include "../7zip/Common/RegisterCodec.h"
 
-Z7_CLASS_IMP_COM_2(
-  CSha256Hasher
-  , IHasher
-  , ICompressSetCoderProperties
-)
-  CAlignedBuffer1 _buf;
-public:
-  Byte _mtDummy[1 << 7];
+class CSha256Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  CSha256 _sha;
+  Byte mtDummy[1 << 7];
 
-  CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_buf; }
 public:
-  CSha256Hasher():
-    _buf(sizeof(CSha256))
-  {
-    Sha256_SetFunction(Sha(), 0);
-    Sha256_InitState(Sha());
-  }
-};
+  CSha256Hasher() { Sha256_Init(&_sha); }
 
-Z7_COM7F_IMF2(void, CSha256Hasher::Init())
-{
-  Sha256_InitState(Sha());
-}
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
 
-Z7_COM7F_IMF2(void, CSha256Hasher::Update(const void *data, UInt32 size))
+STDMETHODIMP_(void) CSha256Hasher::Init() throw()
 {
-  Sha256_Update(Sha(), (const Byte *)data, size);
+  Sha256_Init(&_sha);
 }
 
-Z7_COM7F_IMF2(void, CSha256Hasher::Final(Byte *digest))
+STDMETHODIMP_(void) CSha256Hasher::Update(const void *data, UInt32 size) throw()
 {
-  Sha256_Final(Sha(), digest);
+  Sha256_Update(&_sha, (const Byte *)data, size);
 }
 
-
-Z7_COM7F_IMF(CSha256Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
+STDMETHODIMP_(void) CSha256Hasher::Final(Byte *digest) throw()
 {
-  unsigned algo = 0;
-  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 (prop.ulVal > 2)
-        return E_NOTIMPL;
-      algo = (unsigned)prop.ulVal;
-    }
-  }
-  if (!Sha256_SetFunction(Sha(), algo))
-    return E_NOTIMPL;
-  return S_OK;
+  Sha256_Final(&_sha, digest);
 }
 
 REGISTER_HASHER(CSha256Hasher, 0xA, "SHA256", SHA256_DIGEST_SIZE)

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

@@ -1,7 +1,7 @@
 // StdAfx.h
 
-#ifndef ZIP7_INC_STDAFX_H
-#define ZIP7_INC_STDAFX_H
+#ifndef __STDAFX_H
+#define __STDAFX_H
 
 #include "Common.h"
 

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

@@ -2,9 +2,7 @@
 
 #include "StdAfx.h"
 
-#ifdef _WIN32
 #include <tchar.h>
-#endif
 
 #include "StdInStream.h"
 #include "StringConvert.h"
@@ -14,22 +12,16 @@
 // #define kReadErrorMessage "Error reading input stream"
 // #define kIllegalCharMessage "Illegal zero character in input stream"
 
+#define kFileOpenMode TEXT("r")
 
-CStdInStream g_StdIn(stdin);
+extern int g_CodePage;
 
-/*
-#define kFileOpenMode TEXT("r")
+CStdInStream g_StdIn(stdin);
 
 bool CStdInStream::Open(LPCTSTR fileName) throw()
 {
   Close();
-  _stream =
-    #ifdef _WIN32
-      _tfopen
-    #else
-      fopen
-    #endif
-      (fileName, kFileOpenMode);
+  _stream = _tfopen(fileName, kFileOpenMode);
   _streamIsOpen = (_stream != 0);
   return _streamIsOpen;
 }
@@ -41,22 +33,21 @@ bool CStdInStream::Close() throw()
   _streamIsOpen = (fclose(_stream) != 0);
   return !_streamIsOpen;
 }
-*/
 
 bool CStdInStream::ScanAStringUntilNewLine(AString &s)
 {
   s.Empty();
   for (;;)
   {
-    const int intChar = GetChar();
+    int intChar = GetChar();
     if (intChar == EOF)
       return true;
-    const char c = (char)intChar;
+    char c = (char)intChar;
     if (c == 0)
       return false;
     if (c == '\n')
       return true;
-    s.Add_Char(c);
+    s += c;
   }
 }
 
@@ -64,14 +55,14 @@ bool CStdInStream::ScanUStringUntilNewLine(UString &dest)
 {
   dest.Empty();
   AString s;
-  const bool res = ScanAStringUntilNewLine(s);
-  int codePage = CodePage;
+  bool res = ScanAStringUntilNewLine(s);
+  int codePage = g_CodePage;
   if (codePage == -1)
     codePage = CP_OEMCP;
-  if ((unsigned)codePage == CP_UTF8)
+  if (codePage == CP_UTF8)
     ConvertUTF8ToUnicode(s, dest);
   else
-    MultiByteToUnicodeString2(dest, s, (UINT)(unsigned)codePage);
+    MultiByteToUnicodeString2(dest, s, (UINT)codePage);
   return res;
 }
 

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

@@ -1,7 +1,7 @@
 // Common/StdInStream.h
 
-#ifndef ZIP7_INC_COMMON_STD_IN_STREAM_H
-#define ZIP7_INC_COMMON_STD_IN_STREAM_H
+#ifndef __COMMON_STD_IN_STREAM_H
+#define __COMMON_STD_IN_STREAM_H
 
 #include <stdio.h>
 
@@ -11,22 +11,14 @@
 class CStdInStream
 {
   FILE *_stream;
-  // bool _streamIsOpen;
+  bool _streamIsOpen;
 public:
-  int CodePage;
-
-  CStdInStream(FILE *stream = NULL):
-      _stream(stream),
-      // _streamIsOpen(false),
-      CodePage(-1)
-      {}
-
-  /*
+  CStdInStream(): _stream(0), _streamIsOpen(false) {};
+  CStdInStream(FILE *stream): _stream(stream), _streamIsOpen(false) {};
   ~CStdInStream() { Close(); }
 
   bool Open(LPCTSTR fileName) throw();
   bool Close() throw();
-  */
 
   // returns:
   //   false, if ZERO character in stream