react-native-update 10.34.3 → 10.34.4

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

@@ -1,7 +1,7 @@
-// Common/MyString.h
+// Common/String.h
 
-#ifndef ZIP7_INC_COMMON_MY_STRING_H
-#define ZIP7_INC_COMMON_MY_STRING_H
+#ifndef __COMMON_STRING_H
+#define __COMMON_STRING_H
 
 #include <string.h>
 
@@ -10,23 +10,11 @@
 #include <wchar.h>
 #endif
 
-#include "Common.h"
 #include "MyWindows.h"
 #include "MyTypes.h"
 #include "MyVector.h"
 
 
-/* if (DEBUG_FSTRING_INHERITS_ASTRING is defined), then
-     FString inherits from AString, so we can find bugs related to FString at compile time.
-   DON'T define DEBUG_FSTRING_INHERITS_ASTRING in release code */
-   
-// #define DEBUG_FSTRING_INHERITS_ASTRING
-
-#ifdef DEBUG_FSTRING_INHERITS_ASTRING
-class FString;
-#endif
-
-
 #ifdef _MSC_VER
   #ifdef _NATIVE_WCHAR_T_DEFINED
     #define MY_NATIVE_WCHAR_T_DEFINED
@@ -71,7 +59,7 @@ inline char *MyStpCpy(char *dest, const char *src)
 {
   for (;;)
   {
-    const char c = *src;
+    char c = *src;
     *dest = c;
     if (c == 0)
       return dest;
@@ -80,13 +68,6 @@ inline char *MyStpCpy(char *dest, const char *src)
   }
 }
 
-inline void MyStringCat(char *dest, const char *src)
-{
-  for (; *dest != 0; dest++);
-  while ((*dest++ = *src++) != 0);
-  // MyStringCopy(dest + MyStringLen(dest), src);
-}
-
 inline unsigned MyStringLen(const wchar_t *s)
 {
   unsigned i;
@@ -101,9 +82,7 @@ inline void MyStringCopy(wchar_t *dest, const wchar_t *src)
 
 inline void MyStringCat(wchar_t *dest, const wchar_t *src)
 {
-  for (; *dest != 0; dest++);
-  while ((*dest++ = *src++) != 0);
-  // MyStringCopy(dest + MyStringLen(dest), src);
+  MyStringCopy(dest + MyStringLen(dest), src);
 }
 
 
@@ -112,7 +91,7 @@ inline wchar_t *MyWcpCpy(wchar_t *dest, const wchar_t *src)
 {
   for (;;)
   {
-    const wchar_t c = *src;
+    wchar_t c = *src;
     *dest = c;
     if (c == 0)
       return dest;
@@ -180,7 +159,7 @@ inline wchar_t MyCharUpper(wchar_t c) throw()
       return (wchar_t)MyCharUpper_WIN(c);
     #endif
   #else
-    return (wchar_t)towupper((wint_t)c);
+    return (wchar_t)towupper(c);
   #endif
 }
 
@@ -219,7 +198,6 @@ bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw();
 bool IsString1PrefixedByString2(const char *s1, const char *s2) throw();
 bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw();
 bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw();
-bool IsString1PrefixedByString2_NoCase_Ascii(const char *s1, const char *s2) throw();
 bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *u, const char *a) throw();
 bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw();
 
@@ -229,13 +207,12 @@ int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw();
 
 // ---------- ASCII ----------
 // char values in ASCII strings must be less then 128
-bool StringsAreEqual_Ascii(const char *u, const char *a) throw();
 bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw();
 bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw();
 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw();
 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();
 
-#define MY_STRING_DELETE(_p_) { delete [](_p_); }
+#define MY_STRING_DELETE(_p_) delete []_p_;
 // #define MY_STRING_DELETE(_p_) my_delete(_p_);
 
 
@@ -254,7 +231,7 @@ bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();
   cls &operator=(const t *); \
   cls &operator+=(t); \
   cls &operator+=(const t *); \
-  FORBID_STRING_OPS_2(cls, t) \
+  FORBID_STRING_OPS_2(cls, t); \
 
 /*
   cls &operator+(t); \
@@ -281,8 +258,6 @@ class AString
   void ReAlloc(unsigned newLimit);
   void ReAlloc2(unsigned newLimit);
   void SetStartLen(unsigned len);
-  
-  Z7_NO_INLINE
   void Grow_1();
   void Grow(unsigned n);
 
@@ -291,7 +266,7 @@ class AString
   AString(const AString &s, char c); // it's for String + char
   AString(const char *s1, unsigned num1, const char *s2, unsigned num2);
 
-  friend AString operator+(const AString &s, char c) { return AString(s, c); }
+  friend AString operator+(const AString &s, char c) { return AString(s, c); } ;
   // friend AString operator+(char c, const AString &s); // is not supported
 
   friend AString operator+(const AString &s1, const AString &s2);
@@ -313,28 +288,20 @@ class AString
   FORBID_STRING_OPS_AString(long)
   FORBID_STRING_OPS_AString(unsigned long)
 
- #ifdef DEBUG_FSTRING_INHERITS_ASTRING
-  AString(const FString &s);
-  AString &operator=(const FString &s);
-  AString &operator+=(const FString &s);
- #endif
-
 public:
   explicit AString();
   explicit AString(char c);
   explicit AString(const char *s);
   AString(const AString &s);
-  ~AString() { MY_STRING_DELETE(_chars) }
+  ~AString() { MY_STRING_DELETE(_chars); }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
   void Empty() { _len = 0; _chars[0] = 0; }
 
   operator const char *() const { return _chars; }
-  char *Ptr_non_const() const { return _chars; }
   const char *Ptr() const { return _chars; }
   const char *Ptr(unsigned pos) const { return _chars + pos; }
-  const char *Ptr(int pos) const { return _chars + (unsigned)pos; }
   const char *RightPtr(unsigned num) const { return _chars + _len - num; }
   char Back() const { return _chars[(size_t)_len - 1]; }
 
@@ -375,8 +342,6 @@ public:
   void SetFromWStr_if_Ascii(const wchar_t *s);
   // void SetFromBstr_if_Ascii(BSTR s);
 
-// private:
-  Z7_FORCE_INLINE
   AString &operator+=(char c)
   {
     if (_limit == _len)
@@ -388,35 +353,24 @@ public:
     _len = len;
     return *this;
   }
-public:
+  
   void Add_Space();
   void Add_Space_if_NotEmpty();
   void Add_OptSpaced(const char *s);
-  void Add_Char(char c);
   void Add_LF();
-  void Add_Slash();
-  void Add_Dot();
-  void Add_Minus();
-  void Add_Colon();
   void Add_PathSepar() { operator+=(CHAR_PATH_SEPARATOR); }
 
   AString &operator+=(const char *s);
   AString &operator+=(const AString &s);
 
   void Add_UInt32(UInt32 v);
-  void Add_UInt64(UInt64 v);
 
-  void AddFrom(const char *s, unsigned len); // no check
   void SetFrom(const char *s, unsigned len); // no check
-  void SetFrom_Chars_SizeT(const char* s, size_t len); // no check
-  void SetFrom(const char* s, int len) // no check
-  {
-    SetFrom(s, (unsigned)len); // no check
-  }
   void SetFrom_CalcLen(const char *s, unsigned len);
 
   AString Mid(unsigned startIndex, unsigned count) const { return AString(count, _chars + startIndex); }
   AString Left(unsigned count) const { return AString(count, *this); }
+
   // void MakeUpper() { MyStringUpper(_chars); }
   // void MakeLower() { MyStringLower(_chars); }
   void MakeLower_Ascii() { MyStringLower_Ascii(_chars); }
@@ -429,11 +383,11 @@ public:
   // int CompareNoCase(const char *s) const { return MyStringCompareNoCase(_chars, s); }
   // int CompareNoCase(const AString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
   bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
  
   bool IsAscii() const
   {
-    const unsigned len = Len();
+    unsigned len = Len();
     const char *s = _chars;
     for (unsigned i = 0; i < len; i++)
       if ((unsigned char)s[i] >= 0x80)
@@ -443,13 +397,9 @@ public:
   int Find(char c) const { return FindCharPosInString(_chars, c); }
   int Find(char c, unsigned startIndex) const
   {
-    const int pos = FindCharPosInString(_chars + startIndex, c);
+    int pos = FindCharPosInString(_chars + startIndex, c);
     return pos < 0 ? -1 : (int)startIndex + pos;
   }
-  int Find(char c, int startIndex) const
-  {
-    return Find(c, (unsigned)startIndex);
-  }
   
   int ReverseFind(char c) const throw();
   int ReverseFind_Dot() const throw() { return ReverseFind('.'); }
@@ -488,35 +438,8 @@ public:
       _chars[index] = 0;
     }
   }
-  void DeleteFrom(int index)
-  {
-    DeleteFrom((unsigned)index);
-  }
-
-  
-  void Wipe_and_Empty()
-  {
-    if (_chars)
-    {
-      memset(_chars, 0, (_limit + 1) * sizeof(*_chars));
-      _len = 0;
-    }
-  }
-};
-
-
-class AString_Wipe: public AString
-{
-  Z7_CLASS_NO_COPY(AString_Wipe)
-public:
-  AString_Wipe(): AString() {}
-  // AString_Wipe(const AString &s): AString(s) {}
-  // AString_Wipe &operator=(const AString &s) { AString::operator=(s); return *this; }
-  // AString_Wipe &operator=(const char *s) { AString::operator=(s); return *this; }
-  ~AString_Wipe() { Wipe_and_Empty(); }
 };
 
-
 bool operator<(const AString &s1, const AString &s2);
 bool operator>(const AString &s1, const AString &s2);
 
@@ -577,7 +500,7 @@ class UString
   UString(const UString &s, wchar_t c); // it's for String + char
   UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2);
 
-  friend UString operator+(const UString &s, wchar_t c) { return UString(s, c); }
+  friend UString operator+(const UString &s, wchar_t c) { return UString(s, c); } ;
   // friend UString operator+(wchar_t c, const UString &s); // is not supported
 
   friend UString operator+(const UString &s1, const UString &s2);
@@ -601,30 +524,22 @@ class UString
 
   FORBID_STRING_OPS_2(UString, char)
 
- #ifdef DEBUG_FSTRING_INHERITS_ASTRING
-  UString(const FString &s);
-  UString &operator=(const FString &s);
-  UString &operator+=(const FString &s);
- #endif
-
 public:
   UString();
   explicit UString(wchar_t c);
   explicit UString(char c);
   explicit UString(const char *s);
-  explicit UString(const AString &s);
+  // UString(const AString &s);
   UString(const wchar_t *s);
   UString(const UString &s);
-  ~UString() { MY_STRING_DELETE(_chars) }
+  ~UString() { MY_STRING_DELETE(_chars); }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
   void Empty() { _len = 0; _chars[0] = 0; }
 
   operator const wchar_t *() const { return _chars; }
-  wchar_t *Ptr_non_const() const { return _chars; }
   const wchar_t *Ptr() const { return _chars; }
-  const wchar_t *Ptr(int pos) const { return _chars + (unsigned)pos; }
   const wchar_t *Ptr(unsigned pos) const { return _chars + pos; }
   const wchar_t *RightPtr(unsigned num) const { return _chars + _len - num; }
   wchar_t Back() const { return _chars[(size_t)_len - 1]; }
@@ -633,14 +548,6 @@ public:
 
   wchar_t *GetBuf() { return _chars; }
 
-  /*
-  wchar_t *GetBuf_GetMaxAvail(unsigned &availBufLen)
-  {
-    availBufLen = _limit;
-    return _chars;
-  }
-  */
-
   wchar_t *GetBuf(unsigned minLen)
   {
     if (minLen > _limit)
@@ -671,12 +578,10 @@ public:
   UString &operator=(const wchar_t *s);
   UString &operator=(const UString &s);
   void SetFrom(const wchar_t *s, unsigned len); // no check
-  void SetFromBstr(LPCOLESTR s);
+  void SetFromBstr(BSTR s);
   UString &operator=(const char *s);
   UString &operator=(const AString &s) { return operator=(s.Ptr()); }
 
-// private:
-  Z7_FORCE_INLINE
   UString &operator+=(wchar_t c)
   {
     if (_limit == _len)
@@ -689,17 +594,11 @@ public:
     return *this;
   }
 
-private:
-  UString &operator+=(char c); //  { return (*this)+=((wchar_t)(unsigned char)c); }
-public:
-  void Add_Char(char c);
-  // void Add_WChar(wchar_t c);
+  UString &operator+=(char c) { return (*this)+=((wchar_t)(unsigned char)c); }
+
   void Add_Space();
   void Add_Space_if_NotEmpty();
   void Add_LF();
-  void Add_Dot();
-  void Add_Minus();
-  void Add_Colon();
   void Add_PathSepar() { operator+=(WCHAR_PATH_SEPARATOR); }
 
   UString &operator+=(const wchar_t *s);
@@ -708,11 +607,9 @@ public:
   UString &operator+=(const AString &s) { return operator+=(s.Ptr()); }
 
   void Add_UInt32(UInt32 v);
-  void Add_UInt64(UInt64 v);
 
   UString Mid(unsigned startIndex, unsigned count) const { return UString(count, _chars + startIndex); }
   UString Left(unsigned count) const { return UString(count, *this); }
-  UString Left(int count) const { return Left((unsigned)count); }
 
   // void MakeUpper() { MyStringUpper(_chars); }
   // void MakeUpper() { MyStringUpper_Ascii(_chars); }
@@ -727,23 +624,22 @@ public:
   // int CompareNoCase(const wchar_t *s) const { return MyStringCompareNoCase(_chars, s); }
   // int CompareNoCase(const UString &s) const { return MyStringCompareNoCase(_chars, s._chars); }
   bool IsPrefixedBy(const wchar_t *s) const { return IsString1PrefixedByString2(_chars, s); }
-  bool IsPrefixedBy(const char *s) const { return IsString1PrefixedByString2(_chars, s); }
   bool IsPrefixedBy_NoCase(const wchar_t *s) const { return IsString1PrefixedByString2_NoCase(_chars, s); }
-  bool IsPrefixedBy_Ascii_NoCase(const char *s) const { return IsString1PrefixedByString2_NoCase_Ascii(_chars, s); }
+  bool IsPrefixedBy_Ascii_NoCase(const char *s) const throw();
 
   bool IsAscii() const
   {
-    const unsigned len = Len();
+    unsigned len = Len();
     const wchar_t *s = _chars;
     for (unsigned i = 0; i < len; i++)
-      if ((unsigned)(int)s[i] >= 0x80)
+      if (s[i] >= 0x80)
         return false;
     return true;
   }
   int Find(wchar_t c) const { return FindCharPosInString(_chars, c); }
   int Find(wchar_t c, unsigned startIndex) const
   {
-    const int pos = FindCharPosInString(_chars + startIndex, c);
+    int pos = FindCharPosInString(_chars + startIndex, c);
     return pos < 0 ? -1 : (int)startIndex + pos;
   }
 
@@ -763,7 +659,7 @@ public:
   }
 
   void InsertAtFront(wchar_t c);
-  // void Insert_wchar_t(unsigned index, wchar_t c);
+  // void Insert(unsigned index, wchar_t c);
   void Insert(unsigned index, const wchar_t *s);
   void Insert(unsigned index, const UString &s);
 
@@ -772,12 +668,10 @@ public:
   void Replace(wchar_t oldChar, wchar_t newChar) throw();
   void Replace(const UString &oldString, const UString &newString);
 
-  void Delete(int index) throw() { Delete((unsigned)index); }
   void Delete(unsigned index) throw();
   void Delete(unsigned index, unsigned count) throw();
   void DeleteFrontal(unsigned num) throw();
   void DeleteBack() { _chars[--_len] = 0; }
-  void DeleteFrom(int index) { DeleteFrom((unsigned)index); }
   void DeleteFrom(unsigned index)
   {
     if (index < _len)
@@ -786,30 +680,8 @@ public:
       _chars[index] = 0;
     }
   }
-  
-  void Wipe_and_Empty()
-  {
-    if (_chars)
-    {
-      memset(_chars, 0, (_limit + 1) * sizeof(*_chars));
-      _len = 0;
-    }
-  }
-};
-
-
-class UString_Wipe: public UString
-{
-  Z7_CLASS_NO_COPY(UString_Wipe)
-public:
-  UString_Wipe(): UString() {}
-  // UString_Wipe(const UString &s): UString(s) {}
-  // UString_Wipe &operator=(const UString &s) { UString::operator=(s); return *this; }
-  // UString_Wipe &operator=(const wchar_t *s) { UString::operator=(s); return *this; }
-  ~UString_Wipe() { Wipe_and_Empty(); }
 };
 
-
 bool operator<(const UString &s1, const UString &s2);
 bool operator>(const UString &s1, const UString &s2);
 
@@ -873,22 +745,13 @@ class UString2
   FORBID_STRING_OPS_UString2(short)
 
   UString2 &operator=(wchar_t c);
-
-  UString2(const AString &s);
-  UString2 &operator=(const AString &s);
-  UString2 &operator+=(const AString &s);
-
- #ifdef DEBUG_FSTRING_INHERITS_ASTRING
-  UString2(const FString &s);
-  UString2 &operator=(const FString &s);
-  UString2 &operator+=(const FString &s);
- #endif
+  UString2(wchar_t c);
 
 public:
   UString2(): _chars(NULL), _len(0) {}
   UString2(const wchar_t *s);
   UString2(const UString2 &s);
-  ~UString2() { if (_chars) { MY_STRING_DELETE(_chars) } }
+  ~UString2() { if (_chars) MY_STRING_DELETE(_chars); }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
@@ -958,15 +821,13 @@ typedef CObjectVector<CSysString> CSysStringVector;
 
 // ---------- FString ----------
 
-#ifndef DEBUG_FSTRING_INHERITS_ASTRING
 #ifdef _WIN32
   #define USE_UNICODE_FSTRING
 #endif
-#endif
 
 #ifdef USE_UNICODE_FSTRING
 
-  #define MY_FTEXT(quote) L##quote
+  #define __FTEXT(quote) L##quote
 
   typedef wchar_t FChar;
   typedef UString FString;
@@ -977,65 +838,22 @@ typedef CObjectVector<CSysString> CSysStringVector;
   FString fas2fs(const AString &s);
   AString fs2fas(const FChar *s);
 
-#else // USE_UNICODE_FSTRING
+#else
 
-  #define MY_FTEXT(quote) quote
+  #define __FTEXT(quote) quote
 
   typedef char FChar;
-
- #ifdef DEBUG_FSTRING_INHERITS_ASTRING
-
-  class FString: public AString
-  {
-    // FString &operator=(const char *s);
-    FString &operator=(const AString &s);
-    // FString &operator+=(const AString &s);
-  public:
-    FString(const AString &s): AString(s.Ptr()) {}
-    FString(const FString &s): AString(s.Ptr()) {}
-    FString(const char *s): AString(s) {}
-    FString() {}
-    FString &operator=(const FString &s)  { AString::operator=((const AString &)s); return *this; }
-    FString &operator=(char c) { AString::operator=(c); return *this; }
-    FString &operator+=(char c) { AString::operator+=(c); return *this; }
-    FString &operator+=(const FString &s) { AString::operator+=((const AString &)s); return *this; }
-    FString Left(unsigned count) const  { return FString(AString::Left(count)); }
-  };
-  void operator+(const AString &s1, const FString &s2);
-  void operator+(const FString &s1, const AString &s2);
-
-  inline FString operator+(const FString &s1, const FString &s2)
-  {
-    AString s =(const AString &)s1 + (const AString &)s2;
-    return FString(s.Ptr());
-    // return FString((const AString &)s1 + (const AString &)s2);
-  }
-  inline FString operator+(const FString &s1, const FChar *s2)
-  {
-    return s1 + (FString)s2;
-  }
-  /*
-  inline FString operator+(const FChar *s1, const FString &s2)
-  {
-    return (FString)s1 + s2;
-  }
-  */
-
-  inline FString fas2fs(const char *s)  { return FString(s); }
-
- #else // DEBUG_FSTRING_INHERITS_ASTRING
   typedef AString FString;
-  #define fas2fs(_x_) (_x_)
- #endif // DEBUG_FSTRING_INHERITS_ASTRING
 
   UString fs2us(const FChar *s);
   UString fs2us(const FString &s);
   FString us2fs(const wchar_t *s);
+  #define fas2fs(_x_) (_x_)
   #define fs2fas(_x_) (_x_)
 
-#endif // USE_UNICODE_FSTRING
+#endif
 
-#define FTEXT(quote) MY_FTEXT(quote)
+#define FTEXT(quote) __FTEXT(quote)
 
 #define FCHAR_PATH_SEPARATOR FTEXT(CHAR_PATH_SEPARATOR)
 #define FSTRING_PATH_SEPARATOR FTEXT(STRING_PATH_SEPARATOR)
@@ -1047,33 +865,4 @@ typedef const FChar *CFSTR;
 
 typedef CObjectVector<FString> FStringVector;
 
-
-class CStringFinder
-{
-  AString _temp;
-public:
-  // list - is list of low case Ascii strings separated by space " ".
-  // the function returns true, if it can find exact word (str) in (list).
-  bool FindWord_In_LowCaseAsciiList_NoCase(const char *list, const wchar_t *str);
-};
-
-void SplitString(const UString &srcString, UStringVector &destStrings);
-
-#endif
-
-
-
-#if defined(_WIN32)
-  // #include <wchar.h>
-  // WCHAR_MAX is defined as ((wchar_t)-1)
-  #define Z7_WCHART_IS_16BIT 1
-#elif (defined(WCHAR_MAX) && (WCHAR_MAX <= 0xffff)) \
-   || (defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ == 2))
-  #define Z7_WCHART_IS_16BIT 1
-#endif
-
-#if WCHAR_PATH_SEPARATOR == L'\\'
-// WSL scheme
-#define WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT  ((wchar_t)((unsigned)(0xF000) + (unsigned)'\\'))
-// #define WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT  '_'
 #endif

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

@@ -1,13 +1,11 @@
 // Common/MyTypes.h
 
-#ifndef ZIP7_INC_COMMON_MY_TYPES_H
-#define ZIP7_INC_COMMON_MY_TYPES_H
+#ifndef __COMMON_MY_TYPES_H
+#define __COMMON_MY_TYPES_H
 
-#include "Common0.h"
 #include "../../C/7zTypes.h"
 
-// typedef int HRes;
-// typedef HRESULT HRes;
+typedef int HRes;
 
 struct CBoolPair
 {
@@ -27,12 +25,11 @@ struct CBoolPair
     Val = true;
     Def = true;
   }
-
-  void SetVal_as_Defined(bool val)
-  {
-    Val = val;
-    Def = true;
-  }
 };
 
+#define CLASS_NO_COPY(cls) \
+  private: \
+  cls(const cls &); \
+  cls &operator=(const cls &);
+
 #endif

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

@@ -1,8 +1,17 @@
 // MyUnknown.h
 
-#ifndef ZIP7_INC_MY_UNKNOWN_H
-#define ZIP7_INC_MY_UNKNOWN_H
+#ifndef __MY_UNKNOWN_H
+#define __MY_UNKNOWN_H
 
 #include "MyWindows.h"
 
+/*
+#ifdef _WIN32
+#include <basetyps.h>
+#include <unknwn.h>
+#else
+#include "MyWindows.h"
+#endif
+*/
+  
 #endif