react-native-update 10.34.3 → 10.34.4

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

@@ -30,8 +30,8 @@ inline const char* MyStringGetNextCharPointer(const char *p) throw()
 }
 */
 
-#define MY_STRING_NEW_char(_size_) MY_STRING_NEW(char, (_size_))
-#define MY_STRING_NEW_wchar_t(_size_) MY_STRING_NEW(wchar_t, (_size_))
+#define MY_STRING_NEW_char(_size_) MY_STRING_NEW(char, _size_)
+#define MY_STRING_NEW_wchar_t(_size_) MY_STRING_NEW(wchar_t, _size_)
 
 
 int FindCharPosInString(const char *s, char c) throw()
@@ -62,7 +62,7 @@ void MyStringUpper_Ascii(char *s) throw()
 {
   for (;;)
   {
-    const char c = *s;
+    char c = *s;
     if (c == 0)
       return;
     *s++ = MyCharUpper_Ascii(c);
@@ -73,7 +73,7 @@ void MyStringUpper_Ascii(wchar_t *s) throw()
 {
   for (;;)
   {
-    const wchar_t c = *s;
+    wchar_t c = *s;
     if (c == 0)
       return;
     *s++ = MyCharUpper_Ascii(c);
@@ -85,7 +85,7 @@ void MyStringLower_Ascii(char *s) throw()
 {
   for (;;)
   {
-    const char c = *s;
+    char c = *s;
     if (c == 0)
       return;
     *s++ = MyCharLower_Ascii(c);
@@ -96,7 +96,7 @@ void MyStringLower_Ascii(wchar_t *s) throw()
 {
   for (;;)
   {
-    const wchar_t c = *s;
+    wchar_t c = *s;
     if (c == 0)
       return;
     *s++ = MyCharLower_Ascii(c);
@@ -190,8 +190,8 @@ bool IsString1PrefixedByString2(const char *s1, const char *s2) throw()
 {
   for (;;)
   {
-    const char c2 = *s2++; if (c2 == 0) return true;
-    const char c1 = *s1++; if (c1 != c2) return false;
+    unsigned char c2 = (unsigned char)*s2++; if (c2 == 0) return true;
+    unsigned char c1 = (unsigned char)*s1++; if (c1 != c2) return false;
   }
 }
 
@@ -199,8 +199,8 @@ bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
 {
   for (;;)
   {
-    const wchar_t c1 = *s1++;
-    const wchar_t c2 = *s2++;
+    wchar_t c1 = *s1++;
+    wchar_t c2 = *s2++;
     if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2)) return false;
     if (c1 == 0) return true;
   }
@@ -208,17 +208,32 @@ bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
 
 // ---------- ASCII ----------
 
-bool StringsAreEqual_Ascii(const char *u, const char *a) throw()
+bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
 {
+  const char *s1 = _chars;
   for (;;)
   {
-    const char c = *a;
-    if (c != *u)
+    char c2 = *s++;
+    if (c2 == 0)
+      return true;
+    char c1 = *s1++;
+    if (MyCharLower_Ascii(c1) !=
+        MyCharLower_Ascii(c2))
       return false;
-    if (c == 0)
+  }
+}
+
+bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
+{
+  const wchar_t *s1 = _chars;
+  for (;;)
+  {
+    char c2 = *s++;
+    if (c2 == 0)
       return true;
-    a++;
-    u++;
+    wchar_t c1 = *s1++;
+    if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
+      return false;
   }
 }
 
@@ -226,7 +241,7 @@ bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw()
 {
   for (;;)
   {
-    const unsigned char c = (unsigned char)*a;
+    unsigned char c = *a;
     if (c != *u)
       return false;
     if (c == 0)
@@ -240,8 +255,8 @@ bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw()
 {
   for (;;)
   {
-    const char c1 = *s1++;
-    const char c2 = *s2++;
+    char c1 = *s1++;
+    char c2 = *s2++;
     if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
       return false;
     if (c1 == 0)
@@ -253,8 +268,8 @@ bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw()
 {
   for (;;)
   {
-    const wchar_t c1 = *s1++;
-    const wchar_t c2 = *s2++;
+    wchar_t c1 = *s1++;
+    wchar_t c2 = *s2++;
     if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
       return false;
     if (c1 == 0)
@@ -266,8 +281,8 @@ bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw()
 {
   for (;;)
   {
-    const wchar_t c1 = *s1++;
-    const char c2 = *s2++;
+    wchar_t c1 = *s1++;
+    char c2 = *s2++;
     if (c1 != (unsigned char)c2 && (c1 > 0x7F || MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2)))
       return false;
     if (c1 == 0)
@@ -279,8 +294,8 @@ bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw()
 {
   for (;;)
   {
-    const wchar_t c2 = *s2++; if (c2 == 0) return true;
-    const wchar_t c1 = *s1++; if (c1 != c2) return false;
+    wchar_t c2 = *s2++; if (c2 == 0) return true;
+    wchar_t c1 = *s1++; if (c1 != c2) return false;
   }
 }
 
@@ -288,19 +303,8 @@ bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw()
 {
   for (;;)
   {
-    const unsigned char c2 = (unsigned char)(*s2++); if (c2 == 0) return true;
-    const wchar_t c1 = *s1++; if (c1 != c2) return false;
-  }
-}
-
-bool IsString1PrefixedByString2_NoCase_Ascii(const char *s1, const char *s2) throw()
-{
-  for (;;)
-  {
-    const char c2 = *s2++; if (c2 == 0) return true;
-    const char c1 = *s1++;
-    if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
-      return false;
+    unsigned char c2 = (unsigned char)(*s2++); if (c2 == 0) return true;
+    wchar_t c1 = *s1++; if (c1 != c2) return false;
   }
 }
 
@@ -308,8 +312,8 @@ bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *s1, const char *s2)
 {
   for (;;)
   {
-    const char c2 = *s2++; if (c2 == 0) return true;
-    const wchar_t c1 = *s1++;
+    char c2 = *s2++; if (c2 == 0) return true;
+    wchar_t c1 = *s1++;
     if (c1 != (unsigned char)c2 && MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
       return false;
   }
@@ -319,8 +323,8 @@ bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) thr
 {
   for (;;)
   {
-    const wchar_t c2 = *s2++; if (c2 == 0) return true;
-    const wchar_t c1 = *s1++;
+    wchar_t c2 = *s2++; if (c2 == 0) return true;
+    wchar_t c1 = *s1++;
     if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2))
       return false;
   }
@@ -331,12 +335,12 @@ int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw()
 {
   for (;;)
   {
-    const wchar_t c1 = *s1++;
-    const wchar_t c2 = *s2++;
+    wchar_t c1 = *s1++;
+    wchar_t c2 = *s2++;
     if (c1 != c2)
     {
-      const wchar_t u1 = MyCharUpper(c1);
-      const wchar_t u2 = MyCharUpper(c2);
+      wchar_t u1 = MyCharUpper(c1);
+      wchar_t u2 = MyCharUpper(c2);
       if (u1 < u2) return -1;
       if (u1 > u2) return 1;
     }
@@ -372,75 +376,58 @@ void AString::InsertSpace(unsigned &index, unsigned size)
   MoveItems(index + size, index);
 }
 
-#define k_Alloc_Len_Limit (0x40000000 - 2)
-// #define k_Alloc_Len_Limit (((unsigned)1 << (sizeof(unsigned) * 8 - 2)) - 2)
+#define k_Alloc_Len_Limit 0x40000000
 
 void AString::ReAlloc(unsigned newLimit)
 {
-  // MY_STRING_REALLOC(_chars, char, (size_t)newLimit + 1, (size_t)_len + 1);
-  char *newBuf = MY_STRING_NEW_char((size_t)newLimit + 1);
-  memcpy(newBuf, _chars, (size_t)_len + 1);
-  MY_STRING_DELETE(_chars)
+  if (newLimit < _len || newLimit >= k_Alloc_Len_Limit) throw 20130220;
+  // MY_STRING_REALLOC(_chars, char, newLimit + 1, _len + 1);
+  char *newBuf = MY_STRING_NEW_char(newLimit + 1);
+  memcpy(newBuf, _chars, (size_t)(_len + 1));
+  MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = newLimit;
 }
 
-#define THROW_STRING_ALLOC_EXCEPTION  { throw 20130220; }
-
-#define CHECK_STRING_ALLOC_LEN(len) \
-  { if ((len) > k_Alloc_Len_Limit) THROW_STRING_ALLOC_EXCEPTION }
-
 void AString::ReAlloc2(unsigned newLimit)
 {
-  CHECK_STRING_ALLOC_LEN(newLimit)
-  // MY_STRING_REALLOC(_chars, char, (size_t)newLimit + 1, 0);
-  char *newBuf = MY_STRING_NEW_char((size_t)newLimit + 1);
+  if (newLimit >= k_Alloc_Len_Limit) throw 20130220;
+  // MY_STRING_REALLOC(_chars, char, newLimit + 1, 0);
+  char *newBuf = MY_STRING_NEW_char(newLimit + 1);
   newBuf[0] = 0;
-  MY_STRING_DELETE(_chars)
+  MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = newLimit;
-  _len = 0;
 }
 
 void AString::SetStartLen(unsigned len)
 {
-  _chars = NULL;
-  _chars = MY_STRING_NEW_char((size_t)len + 1);
+  _chars = 0;
+  _chars = MY_STRING_NEW_char(len + 1);
   _len = len;
   _limit = len;
 }
 
-Z7_NO_INLINE
 void AString::Grow_1()
 {
   unsigned next = _len;
   next += next / 2;
   next += 16;
   next &= ~(unsigned)15;
-  next--;
-  if (next < _len || next > k_Alloc_Len_Limit)
-    next = k_Alloc_Len_Limit;
-  if (next <= _len)
-    THROW_STRING_ALLOC_EXCEPTION
-  ReAlloc(next);
-  // Grow(1);
+  ReAlloc(next - 1);
 }
 
 void AString::Grow(unsigned n)
 {
-  const unsigned freeSize = _limit - _len;
+  unsigned freeSize = _limit - _len;
   if (n <= freeSize)
     return;
+  
   unsigned next = _len + n;
   next += next / 2;
   next += 16;
   next &= ~(unsigned)15;
-  next--;
-  if (next < _len || next > k_Alloc_Len_Limit)
-    next = k_Alloc_Len_Limit;
-  if (next <= _len || next - _len < n)
-    THROW_STRING_ALLOC_EXCEPTION
-  ReAlloc(next);
+  ReAlloc(next - 1);
 }
 
 AString::AString(unsigned num, const char *s)
@@ -488,7 +475,7 @@ static const unsigned kStartStringCapacity = 4;
  
 AString::AString()
 {
-  _chars = NULL;
+  _chars = 0;
   _chars = MY_STRING_NEW_char(kStartStringCapacity);
   _len = 0;
   _limit = kStartStringCapacity - 1;
@@ -520,7 +507,7 @@ AString &AString::operator=(char c)
   if (1 > _limit)
   {
     char *newBuf = MY_STRING_NEW_char(1 + 1);
-    MY_STRING_DELETE(_chars)
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = 1;
   }
@@ -536,8 +523,8 @@ AString &AString::operator=(const char *s)
   unsigned len = MyStringLen(s);
   if (len > _limit)
   {
-    char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    char *newBuf = MY_STRING_NEW_char(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -553,8 +540,8 @@ AString &AString::operator=(const AString &s)
   unsigned len = s._len;
   if (len > _limit)
   {
-    char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    char *newBuf = MY_STRING_NEW_char(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -578,8 +565,8 @@ void AString::SetFromWStr_if_Ascii(const wchar_t *s)
   }
   if (len > _limit)
   {
-    char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    char *newBuf = MY_STRING_NEW_char(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -602,8 +589,8 @@ void AString::SetFromBstr_if_Ascii(BSTR s)
   }
   if (len > _limit)
   {
-    char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    char *newBuf = MY_STRING_NEW_char(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -616,14 +603,9 @@ void AString::SetFromBstr_if_Ascii(BSTR s)
 }
 */
 
-void AString::Add_Char(char c) { operator+=(c); }
 void AString::Add_Space() { operator+=(' '); }
 void AString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
 void AString::Add_LF() { operator+=('\n'); }
-void AString::Add_Slash() { operator+=('/'); }
-void AString::Add_Dot() { operator+=('.'); }
-void AString::Add_Minus() { operator+=('-'); }
-void AString::Add_Colon() { operator+=(':'); }
 
 AString &AString::operator+=(const char *s)
 {
@@ -650,35 +632,17 @@ AString &AString::operator+=(const AString &s)
 
 void AString::Add_UInt32(UInt32 v)
 {
-  Grow(10);
-  _len = (unsigned)(ConvertUInt32ToString(v, _chars + _len) - _chars);
-}
-
-void UString::Add_UInt64(UInt64 v)
-{
-  Grow(20);
-  _len = (unsigned)(ConvertUInt64ToString(v, _chars + _len) - _chars);
-}
-
-void AString::AddFrom(const char *s, unsigned len) // no check
-{
-  if (len != 0)
-  {
-    Grow(len);
-    memcpy(_chars + _len, s, len);
-    len += _len;
-    _chars[len] = 0;
-    _len = len;
-  }
+  char sz[16];
+  ConvertUInt32ToString(v, sz);
+  (*this) += sz;
 }
 
 void AString::SetFrom(const char *s, unsigned len) // no check
 {
   if (len > _limit)
   {
-    CHECK_STRING_ALLOC_LEN(len)
-    char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    char *newBuf = MY_STRING_NEW_char(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -688,12 +652,6 @@ void AString::SetFrom(const char *s, unsigned len) // no check
   _len = len;
 }
 
-void AString::SetFrom_Chars_SizeT(const char *s, size_t len)
-{
-  CHECK_STRING_ALLOC_LEN(len)
-  SetFrom(s, (unsigned)len);
-}
-
 void AString::SetFrom_CalcLen(const char *s, unsigned len) // no check
 {
   unsigned i;
@@ -756,7 +714,7 @@ int AString::ReverseFind_PathSepar() const throw()
   const char *p = _chars + _len - 1;
   for (;;)
   {
-    const char c = *p;
+    char c = *p;
     if (IS_PATH_SEPAR(c))
       return (int)(p - _chars);
     if (p == _chars)
@@ -877,7 +835,7 @@ void AString::Replace(char oldChar, char newChar) throw()
   char *chars = _chars;
   while ((unsigned)pos < _len)
   {
-    pos = Find(oldChar, (unsigned)pos);
+    pos = Find(oldChar, pos);
     if (pos < 0)
       break;
     chars[(unsigned)pos] = newChar;
@@ -893,17 +851,17 @@ void AString::Replace(const AString &oldString, const AString &newString)
     return; // 0;
   if (oldString == newString)
     return; // 0;
-  const unsigned oldLen = oldString.Len();
-  const unsigned newLen = newString.Len();
+  unsigned oldLen = oldString.Len();
+  unsigned newLen = newString.Len();
   // unsigned number = 0;
   int pos = 0;
   while ((unsigned)pos < _len)
   {
-    pos = Find(oldString, (unsigned)pos);
+    pos = Find(oldString, pos);
     if (pos < 0)
       break;
-    Delete((unsigned)pos, oldLen);
-    Insert((unsigned)pos, newString);
+    Delete(pos, oldLen);
+    Insert(pos, newString);
     pos += newLen;
     // number++;
   }
@@ -988,63 +946,53 @@ void UString::InsertSpace(unsigned index, unsigned size)
 
 void UString::ReAlloc(unsigned newLimit)
 {
-  // MY_STRING_REALLOC(_chars, wchar_t, (size_t)newLimit + 1, (size_t)_len + 1);
-  wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
+  if (newLimit < _len || newLimit >= k_Alloc_Len_Limit) throw 20130221;
+  // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, _len + 1);
+  wchar_t *newBuf = MY_STRING_NEW_wchar_t(newLimit + 1);
   wmemcpy(newBuf, _chars, _len + 1);
-  MY_STRING_DELETE(_chars)
+  MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = newLimit;
 }
 
 void UString::ReAlloc2(unsigned newLimit)
 {
-  CHECK_STRING_ALLOC_LEN(newLimit)
+  if (newLimit >= k_Alloc_Len_Limit) throw 20130221;
   // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
-  wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
+  wchar_t *newBuf = MY_STRING_NEW_wchar_t(newLimit + 1);
   newBuf[0] = 0;
-  MY_STRING_DELETE(_chars)
+  MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = newLimit;
-  _len = 0;
 }
 
 void UString::SetStartLen(unsigned len)
 {
-  _chars = NULL;
-  _chars = MY_STRING_NEW_wchar_t((size_t)len + 1);
+  _chars = 0;
+  _chars = MY_STRING_NEW_wchar_t(len + 1);
   _len = len;
   _limit = len;
 }
 
-Z7_NO_INLINE
 void UString::Grow_1()
 {
   unsigned next = _len;
   next += next / 2;
   next += 16;
   next &= ~(unsigned)15;
-  next--;
-  if (next < _len || next > k_Alloc_Len_Limit)
-    next = k_Alloc_Len_Limit;
-  if (next <= _len)
-    THROW_STRING_ALLOC_EXCEPTION
-  ReAlloc(next);
+  ReAlloc(next - 1);
 }
 
 void UString::Grow(unsigned n)
 {
-  const unsigned freeSize = _limit - _len;
+  unsigned freeSize = _limit - _len;
   if (n <= freeSize)
     return;
+  
   unsigned next = _len + n;
   next += next / 2;
   next += 16;
   next &= ~(unsigned)15;
-  next--;
-  if (next < _len || next > k_Alloc_Len_Limit)
-    next = k_Alloc_Len_Limit;
-  if (next <= _len || next - _len < n)
-    THROW_STRING_ALLOC_EXCEPTION
   ReAlloc(next - 1);
 }
 
@@ -1093,7 +1041,7 @@ UString operator+(const wchar_t *s1, const UString &s2) { return UString(s1, MyS
 
 UString::UString()
 {
-  _chars = NULL;
+  _chars = 0;
   _chars = MY_STRING_NEW_wchar_t(kStartStringCapacity);
   _len = 0;
   _limit = kStartStringCapacity - 1;
@@ -1118,14 +1066,14 @@ UString::UString(char c)
 
 UString::UString(const wchar_t *s)
 {
-  const unsigned len = MyStringLen(s);
+  unsigned len = MyStringLen(s);
   SetStartLen(len);
   wmemcpy(_chars, s, len + 1);
 }
 
 UString::UString(const char *s)
 {
-  const unsigned len = MyStringLen(s);
+  unsigned len = MyStringLen(s);
   SetStartLen(len);
   wchar_t *chars = _chars;
   for (unsigned i = 0; i < len; i++)
@@ -1133,17 +1081,6 @@ UString::UString(const char *s)
   chars[len] = 0;
 }
 
-UString::UString(const AString &s)
-{
-  const unsigned len = s.Len();
-  SetStartLen(len);
-  wchar_t *chars = _chars;
-  const char *s2 = s.Ptr();
-  for (unsigned i = 0; i < len; i++)
-    chars[i] = (unsigned char)s2[i];
-  chars[len] = 0;
-}
-
 UString::UString(const UString &s)
 {
   SetStartLen(s._len);
@@ -1155,7 +1092,7 @@ UString &UString::operator=(wchar_t c)
   if (1 > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
-    MY_STRING_DELETE(_chars)
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = 1;
   }
@@ -1171,8 +1108,8 @@ UString &UString::operator=(const wchar_t *s)
   unsigned len = MyStringLen(s);
   if (len > _limit)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -1188,8 +1125,8 @@ UString &UString::operator=(const UString &s)
   unsigned len = s._len;
   if (len > _limit)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -1202,9 +1139,8 @@ void UString::SetFrom(const wchar_t *s, unsigned len) // no check
 {
   if (len > _limit)
   {
-    CHECK_STRING_ALLOC_LEN(len)
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -1214,66 +1150,19 @@ void UString::SetFrom(const wchar_t *s, unsigned len) // no check
   _len = len;
 }
 
-void UString::SetFromBstr(LPCOLESTR s)
+void UString::SetFromBstr(BSTR s)
 {
-  unsigned len = ::SysStringLen((BSTR)(void *)(s));
-
-  /*
-  #if WCHAR_MAX > 0xffff
-  size_t num_wchars = 0;
-  for (size_t i = 0; i < len;)
-  {
-    wchar_t c = s[i++];
-    if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
-    {
-      wchar_t c2 = s[i];
-      if (c2 >= 0xdc00 && c2 < 0xe000)
-      {
-        c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
-        i++;
-      }
-    }
-    num_wchars++;
-  }
-  len = num_wchars;
-  #endif
-  */
-
+  unsigned len = ::SysStringLen(s);
   if (len > _limit)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
   _len = len;
-
-  /*
-  #if WCHAR_MAX > 0xffff
-
-  wchar_t *chars = _chars;
-  for (size_t i = 0; i <= len; i++)
-  {
-    wchar_t c = *s++;
-    if (c >= 0xd800 && c < 0xdc00 && i + 1 != len)
-    {
-      wchar_t c2 = *s;
-      if (c2 >= 0xdc00 && c2 < 0xe000)
-      {
-        s++;
-        c = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
-      }
-    }
-    chars[i] = c;
-  }
-
-  #else
-  */
-
   // if (s)
     wmemcpy(_chars, s, len + 1);
-  
-  // #endif
 }
 
 UString &UString::operator=(const char *s)
@@ -1281,8 +1170,8 @@ UString &UString::operator=(const char *s)
   unsigned len = MyStringLen(s);
   if (len > _limit)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars)
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
+    MY_STRING_DELETE(_chars);
     _chars = newBuf;
     _limit = len;
   }
@@ -1294,15 +1183,20 @@ UString &UString::operator=(const char *s)
   return *this;
 }
 
-void UString::Add_Char(char c) { operator+=((wchar_t)(unsigned char)c); }
-// void UString::Add_WChar(wchar_t c) { operator+=(c); }
-void UString::Add_Dot() { operator+=(L'.'); }
 void UString::Add_Space() { operator+=(L' '); }
-void UString::Add_Minus() { operator+=(L'-'); }
-void UString::Add_Colon() { operator+=(L':'); }
-void UString::Add_LF() { operator+=(L'\n'); }
 void UString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
 
+void UString::Add_LF()
+{
+  if (_limit == _len)
+    Grow_1();
+  unsigned len = _len;
+  wchar_t *chars = _chars;
+  chars[len++] = L'\n';
+  chars[len] = 0;
+  _len = len;
+}
+
 UString &UString::operator+=(const wchar_t *s)
 {
   unsigned len = MyStringLen(s);
@@ -1335,14 +1229,9 @@ UString &UString::operator+=(const char *s)
 
 void UString::Add_UInt32(UInt32 v)
 {
-  Grow(10);
-  _len = (unsigned)(ConvertUInt32ToString(v, _chars + _len) - _chars);
-}
-
-void AString::Add_UInt64(UInt64 v)
-{
-  Grow(20);
-  _len = (unsigned)(ConvertUInt64ToString(v, _chars + _len) - _chars);
+  char sz[16];
+  ConvertUInt32ToString(v, sz);
+  (*this) += sz;
 }
 
 
@@ -1381,26 +1270,31 @@ int UString::ReverseFind(wchar_t c) const throw()
 {
   if (_len == 0)
     return -1;
-  const wchar_t *p = _chars + _len;
-  do
+  const wchar_t *p = _chars + _len - 1;
+  for (;;)
   {
-    if (*(--p) == c)
+    if (*p == c)
       return (int)(p - _chars);
+    if (p == _chars)
+      return -1;
+    p--;
   }
-  while (p != _chars);
-  return -1;
 }
 
 int UString::ReverseFind_PathSepar() const throw()
 {
-  const wchar_t *p = _chars + _len;
-  while (p != _chars)
+  if (_len == 0)
+    return -1;
+  const wchar_t *p = _chars + _len - 1;
+  for (;;)
   {
-    const wchar_t c = *(--p);
+    wchar_t c = *p;
     if (IS_PATH_SEPAR(c))
       return (int)(p - _chars);
+    if (p == _chars)
+      return -1;
+    p--;
   }
-  return -1;
 }
 
 void UString::TrimLeft() throw()
@@ -1447,7 +1341,7 @@ void UString::InsertAtFront(wchar_t c)
 }
 
 /*
-void UString::Insert_wchar_t(unsigned index, wchar_t c)
+void UString::Insert(unsigned index, wchar_t c)
 {
   InsertSpace(index, 1);
   _chars[index] = c;
@@ -1515,7 +1409,7 @@ void UString::Replace(wchar_t oldChar, wchar_t newChar) throw()
   wchar_t *chars = _chars;
   while ((unsigned)pos < _len)
   {
-    pos = Find(oldChar, (unsigned)pos);
+    pos = Find(oldChar, pos);
     if (pos < 0)
       break;
     chars[(unsigned)pos] = newChar;
@@ -1537,11 +1431,11 @@ void UString::Replace(const UString &oldString, const UString &newString)
   int pos = 0;
   while ((unsigned)pos < _len)
   {
-    pos = Find(oldString, (unsigned)pos);
+    pos = Find(oldString, pos);
     if (pos < 0)
       break;
-    Delete((unsigned)pos, oldLen);
-    Insert((unsigned)pos, newString);
+    Delete(pos, oldLen);
+    Insert(pos, newString);
     pos += newLen;
     // number++;
   }
@@ -1579,24 +1473,15 @@ void UString::DeleteFrontal(unsigned num) throw()
 
 void UString2::ReAlloc2(unsigned newLimit)
 {
-  // wrong (_len) is allowed after this function
-  CHECK_STRING_ALLOC_LEN(newLimit)
+  if (newLimit >= k_Alloc_Len_Limit) throw 20130221;
   // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
-  if (_chars)
-  {
-    MY_STRING_DELETE(_chars)
-    _chars = NULL;
-    // _len = 0;
-  }
-  _chars = MY_STRING_NEW_wchar_t((size_t)newLimit + 1);
-  _chars[0] = 0;
-  // _len = newLimit;
+  _chars = MY_STRING_NEW_wchar_t(newLimit + 1);
 }
 
 void UString2::SetStartLen(unsigned len)
 {
-  _chars = NULL;
-  _chars = MY_STRING_NEW_wchar_t((size_t)len + 1);
+  _chars = 0;
+  _chars = MY_STRING_NEW_wchar_t(len + 1);
   _len = len;
 }
 
@@ -1613,7 +1498,7 @@ UString2::UString2(wchar_t c)
 
 UString2::UString2(const wchar_t *s)
 {
-  const unsigned len = MyStringLen(s);
+  unsigned len = MyStringLen(s);
   SetStartLen(len);
   wmemcpy(_chars, s, len + 1);
 }
@@ -1634,7 +1519,7 @@ UString2 &UString2::operator=(wchar_t c)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars)
+      MY_STRING_DELETE(_chars);
     _chars = newBuf;
   }
   _len = 1;
@@ -1650,9 +1535,9 @@ UString2 &UString2::operator=(const wchar_t *s)
   unsigned len = MyStringLen(s);
   if (len > _len)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars)
+      MY_STRING_DELETE(_chars);
     _chars = newBuf;
   }
   _len = len;
@@ -1665,9 +1550,9 @@ void UString2::SetFromAscii(const char *s)
   unsigned len = MyStringLen(s);
   if (len > _len)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars)
+      MY_STRING_DELETE(_chars);
     _chars = newBuf;
   }
   wchar_t *chars = _chars;
@@ -1684,9 +1569,9 @@ UString2 &UString2::operator=(const UString2 &s)
   unsigned len = s._len;
   if (len > _len)
   {
-    wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
+    wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars)
+      MY_STRING_DELETE(_chars);
     _chars = newBuf;
   }
   _len = len;
@@ -1724,8 +1609,6 @@ int MyStringCompareNoCase(const char *s1, const char *s2)
 }
 */
 
-#if !defined(USE_UNICODE_FSTRING) || !defined(_UNICODE)
-
 static inline UINT GetCurrentCodePage()
 {
   #if defined(UNDER_CE) || !defined(_WIN32)
@@ -1735,8 +1618,6 @@ static inline UINT GetCurrentCodePage()
   #endif
 }
 
-#endif
-
 #ifdef USE_UNICODE_FSTRING
 
 #ifndef _UNICODE
@@ -1756,9 +1637,9 @@ FString fas2fs(const AString &s)
   return MultiByteToUnicodeString(s, GetCurrentCodePage());
 }
 
-#endif //  _UNICODE
+#endif
 
-#else // USE_UNICODE_FSTRING
+#else
 
 UString fs2us(const FChar *s)
 {
@@ -1775,68 +1656,4 @@ FString us2fs(const wchar_t *s)
   return UnicodeStringToMultiByte(s, GetCurrentCodePage());
 }
 
-#endif // USE_UNICODE_FSTRING
-
-
-bool CStringFinder::FindWord_In_LowCaseAsciiList_NoCase(const char *p, const wchar_t *str)
-{
-  _temp.Empty();
-  for (;;)
-  {
-    const wchar_t c = *str++;
-    if (c == 0)
-      break;
-    if (c <= 0x20 || c > 0x7f)
-      return false;
-    _temp.Add_Char((char)MyCharLower_Ascii((char)c));
-  }
-
-  while (*p != 0)
-  {
-    const char *s2 = _temp.Ptr();
-    char c, c2;
-    do
-    {
-      c = *p++;
-      c2 = *s2++;
-    }
-    while (c == c2);
-    
-    if (c == ' ')
-    {
-      if (c2 == 0)
-        return true;
-      continue;
-    }
-    
-    while (*p++ != ' ');
-  }
-  
-  return false;
-}
-
-
-void SplitString(const UString &srcString, UStringVector &destStrings)
-{
-  destStrings.Clear();
-  unsigned len = srcString.Len();
-  if (len == 0)
-    return;
-  UString s;
-  for (unsigned i = 0; i < len; i++)
-  {
-    const wchar_t c = srcString[i];
-    if (c == ' ')
-    {
-      if (!s.IsEmpty())
-      {
-        destStrings.Add(s);
-        s.Empty();
-      }
-    }
-    else
-      s += c;
-  }
-  if (!s.IsEmpty())
-    destStrings.Add(s);
-}
+#endif