react-native-update 10.34.2 → 10.34.4

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

@@ -0,0 +1,89 @@
+// Common/StdInStream.cpp
+
+#include "StdAfx.h"
+
+#include <tchar.h>
+
+#include "StdInStream.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
+
+// #define kEOFMessage "Unexpected end of input stream"
+// #define kReadErrorMessage "Error reading input stream"
+// #define kIllegalCharMessage "Illegal zero character in input stream"
+
+#define kFileOpenMode TEXT("r")
+
+extern int g_CodePage;
+
+CStdInStream g_StdIn(stdin);
+
+bool CStdInStream::Open(LPCTSTR fileName) throw()
+{
+  Close();
+  _stream = _tfopen(fileName, kFileOpenMode);
+  _streamIsOpen = (_stream != 0);
+  return _streamIsOpen;
+}
+
+bool CStdInStream::Close() throw()
+{
+  if (!_streamIsOpen)
+    return true;
+  _streamIsOpen = (fclose(_stream) != 0);
+  return !_streamIsOpen;
+}
+
+bool CStdInStream::ScanAStringUntilNewLine(AString &s)
+{
+  s.Empty();
+  for (;;)
+  {
+    int intChar = GetChar();
+    if (intChar == EOF)
+      return true;
+    char c = (char)intChar;
+    if (c == 0)
+      return false;
+    if (c == '\n')
+      return true;
+    s += c;
+  }
+}
+
+bool CStdInStream::ScanUStringUntilNewLine(UString &dest)
+{
+  dest.Empty();
+  AString s;
+  bool res = ScanAStringUntilNewLine(s);
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  if (codePage == CP_UTF8)
+    ConvertUTF8ToUnicode(s, dest);
+  else
+    MultiByteToUnicodeString2(dest, s, (UINT)codePage);
+  return res;
+}
+
+/*
+bool CStdInStream::ReadToString(AString &resultString)
+{
+  resultString.Empty();
+  for (;;)
+  {
+    int intChar = GetChar();
+    if (intChar == EOF)
+      return !Error();
+    char c = (char)intChar;
+    if (c == 0)
+      return false;
+    resultString += c;
+  }
+}
+*/
+
+int CStdInStream::GetChar()
+{
+  return fgetc(_stream); // getc() doesn't work in BeOS?
+}

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

@@ -0,0 +1,38 @@
+// Common/StdInStream.h
+
+#ifndef __COMMON_STD_IN_STREAM_H
+#define __COMMON_STD_IN_STREAM_H
+
+#include <stdio.h>
+
+#include "MyString.h"
+#include "MyTypes.h"
+
+class CStdInStream
+{
+  FILE *_stream;
+  bool _streamIsOpen;
+public:
+  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
+  //   true, if EOF or '\n'
+  bool ScanAStringUntilNewLine(AString &s);
+  bool ScanUStringUntilNewLine(UString &s);
+  // bool ReadToString(AString &resultString);
+
+  bool Eof() const throw() { return (feof(_stream) != 0); }
+  bool Error() const throw() { return (ferror(_stream) != 0); }
+
+  int GetChar();
+};
+
+extern CStdInStream g_StdIn;
+
+#endif

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

@@ -0,0 +1,163 @@
+// Common/StdOutStream.cpp
+
+#include "StdAfx.h"
+
+#include <tchar.h>
+
+#include "IntToString.h"
+#include "StdOutStream.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
+
+#define kFileOpenMode "wt"
+
+extern int g_CodePage;
+
+CStdOutStream g_StdOut(stdout);
+CStdOutStream g_StdErr(stderr);
+
+bool CStdOutStream::Open(const char *fileName) throw()
+{
+  Close();
+  _stream = fopen(fileName, kFileOpenMode);
+  _streamIsOpen = (_stream != 0);
+  return _streamIsOpen;
+}
+
+bool CStdOutStream::Close() throw()
+{
+  if (!_streamIsOpen)
+    return true;
+  if (fclose(_stream) != 0)
+    return false;
+  _stream = 0;
+  _streamIsOpen = false;
+  return true;
+}
+
+bool CStdOutStream::Flush() throw()
+{
+  return (fflush(_stream) == 0);
+}
+
+CStdOutStream & endl(CStdOutStream & outStream) throw()
+{
+  return outStream << '\n';
+}
+
+CStdOutStream & CStdOutStream::operator<<(const wchar_t *s)
+{
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  AString dest;
+  if (codePage == CP_UTF8)
+    ConvertUnicodeToUTF8(s, dest);
+  else
+    UnicodeStringToMultiByte2(dest, s, (UINT)codePage);
+  return operator<<((const char *)dest);
+}
+
+void StdOut_Convert_UString_to_AString(const UString &s, AString &temp)
+{
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  if (codePage == CP_UTF8)
+    ConvertUnicodeToUTF8(s, temp);
+  else
+    UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
+}
+
+void CStdOutStream::PrintUString(const UString &s, AString &temp)
+{
+  StdOut_Convert_UString_to_AString(s, temp);
+  *this << (const char *)temp;
+}
+
+
+static const wchar_t kReplaceChar = '_';
+
+void CStdOutStream::Normalize_UString__LF_Allowed(UString &s)
+{
+  unsigned len = s.Len();
+  wchar_t *d = s.GetBuf();
+
+  if (IsTerminalMode)
+    for (unsigned i = 0; i < len; i++)
+    {
+      wchar_t c = d[i];
+      if (c <= 13 && c >= 7 && c != '\n')
+        d[i] = kReplaceChar;
+    }
+}
+
+void CStdOutStream::Normalize_UString(UString &s)
+{
+  unsigned len = s.Len();
+  wchar_t *d = s.GetBuf();
+
+  if (IsTerminalMode)
+    for (unsigned i = 0; i < len; i++)
+    {
+      wchar_t c = d[i];
+      if (c <= 13 && c >= 7)
+        d[i] = kReplaceChar;
+    }
+  else
+    for (unsigned i = 0; i < len; i++)
+    {
+      wchar_t c = d[i];
+      if (c == '\n')
+        d[i] = kReplaceChar;
+    }
+}
+
+void CStdOutStream::NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA)
+{
+  tempU = s;
+  Normalize_UString(tempU);
+  PrintUString(tempU, tempA);
+}
+
+void CStdOutStream::NormalizePrint_UString(const UString &s)
+{
+  NormalizePrint_wstr(s);
+}
+
+void CStdOutStream::NormalizePrint_wstr(const wchar_t *s)
+{
+  UString tempU = s;
+  Normalize_UString(tempU);
+  AString tempA;
+  PrintUString(tempU, tempA);
+}
+
+
+CStdOutStream & CStdOutStream::operator<<(Int32 number) throw()
+{
+  char s[32];
+  ConvertInt64ToString(number, s);
+  return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(Int64 number) throw()
+{
+  char s[32];
+  ConvertInt64ToString(number, s);
+  return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(UInt32 number) throw()
+{
+  char s[16];
+  ConvertUInt32ToString(number, s);
+  return operator<<(s);
+}
+
+CStdOutStream & CStdOutStream::operator<<(UInt64 number) throw()
+{
+  char s[32];
+  ConvertUInt64ToString(number, s);
+  return operator<<(s);
+}

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

@@ -0,0 +1,71 @@
+// Common/StdOutStream.h
+
+#ifndef __COMMON_STD_OUT_STREAM_H
+#define __COMMON_STD_OUT_STREAM_H
+
+#include <stdio.h>
+
+#include "MyString.h"
+#include "MyTypes.h"
+
+class CStdOutStream
+{
+  FILE *_stream;
+  bool _streamIsOpen;
+public:
+  bool IsTerminalMode;
+
+  CStdOutStream(): _stream(0), _streamIsOpen(false), IsTerminalMode(false) {};
+  CStdOutStream(FILE *stream): _stream(stream), _streamIsOpen(false) {};
+  ~CStdOutStream() { Close(); }
+
+  // void AttachStdStream(FILE *stream) { _stream  = stream; _streamIsOpen = false; }
+  // bool IsDefined() const { return _stream  != NULL; }
+
+  operator FILE *() { return _stream; }
+  bool Open(const char *fileName) throw();
+  bool Close() throw();
+  bool Flush() throw();
+  
+  CStdOutStream & operator<<(CStdOutStream & (* func)(CStdOutStream  &))
+  {
+    (*func)(*this);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(const char *s) throw()
+  {
+    fputs(s, _stream);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(char c) throw()
+  {
+    fputc((unsigned char)c, _stream);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(Int32 number) throw();
+  CStdOutStream & operator<<(Int64 number) throw();
+  CStdOutStream & operator<<(UInt32 number) throw();
+  CStdOutStream & operator<<(UInt64 number) throw();
+
+  CStdOutStream & operator<<(const wchar_t *s);
+  void PrintUString(const UString &s, AString &temp);
+
+  void Normalize_UString__LF_Allowed(UString &s);
+  void Normalize_UString(UString &s);
+
+  void NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA);
+  void NormalizePrint_UString(const UString &s);
+  void NormalizePrint_wstr(const wchar_t *s);
+};
+
+CStdOutStream & endl(CStdOutStream & outStream) throw();
+
+extern CStdOutStream g_StdOut;
+extern CStdOutStream g_StdErr;
+
+void StdOut_Convert_UString_to_AString(const UString &s, AString &temp);
+
+#endif

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

@@ -0,0 +1,319 @@
+// Common/StringConvert.cpp
+
+#include "StdAfx.h"
+
+#include "StringConvert.h"
+
+#ifndef _WIN32
+#include <stdlib.h>
+#endif
+
+static const char k_DefultChar = '_';
+
+#ifdef _WIN32
+
+/*
+MultiByteToWideChar(CodePage, DWORD dwFlags,
+    LPCSTR lpMultiByteStr, int cbMultiByte,
+    LPWSTR lpWideCharStr, int cchWideChar)
+
+  if (cbMultiByte == 0)
+    return: 0. ERR: ERROR_INVALID_PARAMETER
+
+  if (cchWideChar == 0)
+    return: the required buffer size in characters.
+
+  if (supplied buffer size was not large enough)
+    return: 0. ERR: ERROR_INSUFFICIENT_BUFFER
+    The number of filled characters in lpWideCharStr can be smaller than cchWideChar (if last character is complex)
+
+  If there are illegal characters:
+    if MB_ERR_INVALID_CHARS is set in dwFlags:
+      - the function stops conversion on illegal character.
+      - Return: 0. ERR: ERROR_NO_UNICODE_TRANSLATION.
+    
+    if MB_ERR_INVALID_CHARS is NOT set in dwFlags:
+      before Vista: illegal character is dropped (skipped). WinXP-64: GetLastError() returns 0.
+      in Vista+:    illegal character is not dropped (MSDN). Undocumented: illegal
+                    character is converted to U+FFFD, which is REPLACEMENT CHARACTER.
+*/
+
+
+void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT codePage)
+{
+  dest.Empty();
+  if (src.IsEmpty())
+    return;
+  {
+    /*
+    wchar_t *d = dest.GetBuf(src.Len());
+    const char *s = (const char *)src;
+    unsigned i;
+    
+    for (i = 0;;)
+    {
+      Byte c = (Byte)s[i];
+      if (c >= 0x80 || c == 0)
+        break;
+      d[i++] = (wchar_t)c;
+    }
+
+    if (i != src.Len())
+    {
+      unsigned len = MultiByteToWideChar(codePage, 0, s + i,
+          src.Len() - i, d + i,
+          src.Len() + 1 - i);
+      if (len == 0)
+        throw 282228;
+      i += len;
+    }
+
+    d[i] = 0;
+    dest.ReleaseBuf_SetLen(i);
+    */
+    unsigned len = MultiByteToWideChar(codePage, 0, src, src.Len(), NULL, 0);
+    if (len == 0)
+    {
+      if (GetLastError() != 0)
+        throw 282228;
+    }
+    else
+    {
+      len = MultiByteToWideChar(codePage, 0, src, src.Len(), dest.GetBuf(len), len);
+      if (len == 0)
+        throw 282228;
+      dest.ReleaseBuf_SetEnd(len);
+    }
+  }
+}
+
+/*
+  int WideCharToMultiByte(
+      UINT CodePage, DWORD dwFlags,
+      LPCWSTR lpWideCharStr, int cchWideChar,
+      LPSTR lpMultiByteStr, int cbMultiByte,
+      LPCSTR lpDefaultChar, LPBOOL lpUsedDefaultChar);
+
+if (lpDefaultChar == NULL),
+  - it uses system default value.
+
+if (CodePage == CP_UTF7 || CodePage == CP_UTF8)
+  if (lpDefaultChar != NULL || lpUsedDefaultChar != NULL)
+    return: 0. ERR: ERROR_INVALID_PARAMETER.
+
+The function operates most efficiently, if (lpDefaultChar == NULL && lpUsedDefaultChar == NULL)
+
+*/
+
+static void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
+{
+  dest.Empty();
+  defaultCharWasUsed = false;
+  if (src.IsEmpty())
+    return;
+  {
+    /*
+    unsigned numRequiredBytes = src.Len() * 2;
+    char *d = dest.GetBuf(numRequiredBytes);
+    const wchar_t *s = (const wchar_t *)src;
+    unsigned i;
+    
+    for (i = 0;;)
+    {
+      wchar_t c = s[i];
+      if (c >= 0x80 || c == 0)
+        break;
+      d[i++] = (char)c;
+    }
+    
+    if (i != src.Len())
+    {
+      BOOL defUsed = FALSE;
+      defaultChar = defaultChar;
+
+      bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
+      unsigned len = WideCharToMultiByte(codePage, 0, s + i, src.Len() - i,
+          d + i, numRequiredBytes + 1 - i,
+          (isUtf ? NULL : &defaultChar),
+          (isUtf ? NULL : &defUsed));
+      defaultCharWasUsed = (defUsed != FALSE);
+      if (len == 0)
+        throw 282229;
+      i += len;
+    }
+
+    d[i] = 0;
+    dest.ReleaseBuf_SetLen(i);
+    */
+
+    /*
+    if (codePage != CP_UTF7)
+    {
+      const wchar_t *s = (const wchar_t *)src;
+      unsigned i;
+      for (i = 0;; i++)
+      {
+        wchar_t c = s[i];
+        if (c >= 0x80 || c == 0)
+          break;
+      }
+      
+      if (s[i] == 0)
+      {
+        char *d = dest.GetBuf(src.Len());
+        for (i = 0;;)
+        {
+          wchar_t c = s[i];
+          if (c == 0)
+            break;
+          d[i++] = (char)c;
+        }
+        d[i] = 0;
+        dest.ReleaseBuf_SetLen(i);
+        return;
+      }
+    }
+    */
+
+    unsigned len = WideCharToMultiByte(codePage, 0, src, src.Len(), NULL, 0, NULL, NULL);
+    if (len == 0)
+    {
+      if (GetLastError() != 0)
+        throw 282228;
+    }
+    else
+    {
+      BOOL defUsed = FALSE;
+      bool isUtf = (codePage == CP_UTF8 || codePage == CP_UTF7);
+      // defaultChar = defaultChar;
+      len = WideCharToMultiByte(codePage, 0, src, src.Len(),
+          dest.GetBuf(len), len,
+          (isUtf ? NULL : &defaultChar),
+          (isUtf ? NULL : &defUsed)
+          );
+      if (!isUtf)
+        defaultCharWasUsed = (defUsed != FALSE);
+      if (len == 0)
+        throw 282228;
+      dest.ReleaseBuf_SetEnd(len);
+    }
+  }
+}
+
+/*
+#ifndef UNDER_CE
+AString SystemStringToOemString(const CSysString &src)
+{
+  AString dest;
+  const unsigned len = src.Len() * 2;
+  CharToOem(src, dest.GetBuf(len));
+  dest.ReleaseBuf_CalcLen(len);
+  return dest;
+}
+#endif
+*/
+
+#else
+
+void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT /* codePage */)
+{
+  dest.Empty();
+  if (src.IsEmpty())
+    return;
+
+  size_t limit = ((size_t)src.Len() + 1) * 2;
+  wchar_t *d = dest.GetBuf((unsigned)limit);
+  size_t len = mbstowcs(d, src, limit);
+  if (len != (size_t)-1)
+  {
+    dest.ReleaseBuf_SetEnd((unsigned)len);
+    return;
+  }
+  
+  {
+    unsigned i;
+    const char *s = (const char *)src;
+    for (i = 0;;)
+    {
+      Byte c = (Byte)s[i];
+      if (c == 0)
+        break;
+      d[i++] = (wchar_t)c;
+    }
+    d[i] = 0;
+    dest.ReleaseBuf_SetLen(i);
+  }
+}
+
+static void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT /* codePage */, char defaultChar, bool &defaultCharWasUsed)
+{
+  dest.Empty();
+  defaultCharWasUsed = false;
+  if (src.IsEmpty())
+    return;
+
+  size_t limit = ((size_t)src.Len() + 1) * 6;
+  char *d = dest.GetBuf((unsigned)limit);
+  size_t len = wcstombs(d, src, limit);
+  if (len != (size_t)-1)
+  {
+    dest.ReleaseBuf_SetEnd((unsigned)len);
+    return;
+  }
+
+  {
+    const wchar_t *s = (const wchar_t *)src;
+    unsigned i;
+    for (i = 0;;)
+    {
+      wchar_t c = s[i];
+      if (c == 0)
+        break;
+      if (c >= 0x100)
+      {
+        c = defaultChar;
+        defaultCharWasUsed = true;
+      }
+      d[i++] = (char)c;
+    }
+    d[i] = 0;
+    dest.ReleaseBuf_SetLen(i);
+  }
+}
+
+#endif
+
+
+UString MultiByteToUnicodeString(const AString &src, UINT codePage)
+{
+  UString dest;
+  MultiByteToUnicodeString2(dest, src, codePage);
+  return dest;
+}
+
+UString MultiByteToUnicodeString(const char *src, UINT codePage)
+{
+  return MultiByteToUnicodeString(AString(src), codePage);
+}
+
+
+void UnicodeStringToMultiByte2(AString &dest, const UString &src, UINT codePage)
+{
+  bool defaultCharWasUsed;
+  UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
+}
+
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage, char defaultChar, bool &defaultCharWasUsed)
+{
+  AString dest;
+  UnicodeStringToMultiByte2(dest, src, codePage, defaultChar, defaultCharWasUsed);
+  return dest;
+}
+
+AString UnicodeStringToMultiByte(const UString &src, UINT codePage)
+{
+  AString dest;
+  bool defaultCharWasUsed;
+  UnicodeStringToMultiByte2(dest, src, codePage, k_DefultChar, defaultCharWasUsed);
+  return dest;
+}