tor-browser

MyString.cpp (33232B)

---

// Common/MyString.cpp

#include "StdAfx.h"

#ifdef _WIN32
#include <wchar.h>
#else
#include <ctype.h>
#endif

#include "IntToString.h"

#if !defined(_UNICODE) || !defined(USE_UNICODE_FSTRING)
#include "StringConvert.h"
#endif

#include "MyString.h"

#define MY_STRING_NEW(_T_, _size_) new _T_[_size_]
// #define MY_STRING_NEW(_T_, _size_) ((_T_ *)my_new((size_t)(_size_) * sizeof(_T_)))

/*
inline const char* MyStringGetNextCharPointer(const char *p) throw()
{
 #if defined(_WIN32) && !defined(UNDER_CE)
 return CharNextA(p);
 #else
 return p + 1;
 #endif
}
*/

#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()
{
 for (const char *p = s;; p++)
 {
   if (*p == c)
     return (int)(p - s);
   if (*p == 0)
     return -1;
   // MyStringGetNextCharPointer(p);
 }
}

int FindCharPosInString(const wchar_t *s, wchar_t c) throw()
{
 for (const wchar_t *p = s;; p++)
 {
   if (*p == c)
     return (int)(p - s);
   if (*p == 0)
     return -1;
 }
}

/*
void MyStringUpper_Ascii(char *s) throw()
{
 for (;;)
 {
   char c = *s;
   if (c == 0)
     return;
   *s++ = MyCharUpper_Ascii(c);
 }
}

void MyStringUpper_Ascii(wchar_t *s) throw()
{
 for (;;)
 {
   wchar_t c = *s;
   if (c == 0)
     return;
   *s++ = MyCharUpper_Ascii(c);
 }
}
*/

void MyStringLower_Ascii(char *s) throw()
{
 for (;;)
 {
   char c = *s;
   if (c == 0)
     return;
   *s++ = MyCharLower_Ascii(c);
 }
}

void MyStringLower_Ascii(wchar_t *s) throw()
{
 for (;;)
 {
   wchar_t c = *s;
   if (c == 0)
     return;
   *s++ = MyCharLower_Ascii(c);
 }
}

#ifdef _WIN32

#ifdef _UNICODE

// wchar_t * MyStringUpper(wchar_t *s) { return CharUpperW(s); }
// wchar_t * MyStringLower(wchar_t *s) { return CharLowerW(s); }
// for WinCE - FString - char
// const char *MyStringGetPrevCharPointer(const char * /* base */, const char *p) { return p - 1; }

#else

// const char * MyStringGetPrevCharPointer(const char *base, const char *p) throw() { return CharPrevA(base, p); }
// char * MyStringUpper(char *s) { return CharUpperA(s); }
// char * MyStringLower(char *s) { return CharLowerA(s); }

wchar_t MyCharUpper_WIN(wchar_t c) throw()
{
 wchar_t *res = CharUpperW((LPWSTR)(UINT_PTR)(unsigned)c);
 if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
   return (wchar_t)(unsigned)(UINT_PTR)res;
 const int kBufSize = 4;
 char s[kBufSize + 1];
 int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
 if (numChars == 0 || numChars > kBufSize)
   return c;
 s[numChars] = 0;
 ::CharUpperA(s);
 ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
 return c;
}

/*
wchar_t MyCharLower_WIN(wchar_t c)
{
 wchar_t *res = CharLowerW((LPWSTR)(UINT_PTR)(unsigned)c);
 if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
   return (wchar_t)(unsigned)(UINT_PTR)res;
 const int kBufSize = 4;
 char s[kBufSize + 1];
 int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufSize, 0, 0);
 if (numChars == 0 || numChars > kBufSize)
   return c;
 s[numChars] = 0;
 ::CharLowerA(s);
 ::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
 return c;
}
*/

/*
wchar_t * MyStringUpper(wchar_t *s)
{
 if (s == 0)
   return 0;
 wchar_t *res = CharUpperW(s);
 if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
   return res;
 AString a = UnicodeStringToMultiByte(s);
 a.MakeUpper();
 MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
 return s;
}
*/

/*
wchar_t * MyStringLower(wchar_t *s)
{
 if (s == 0)
   return 0;
 wchar_t *res = CharLowerW(s);
 if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
   return res;
 AString a = UnicodeStringToMultiByte(s);
 a.MakeLower();
 MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
 return s;
}
*/

#endif

#endif

bool IsString1PrefixedByString2(const char *s1, const char *s2) throw()
{
 for (;;)
 {
   unsigned char c2 = (unsigned char)*s2++; if (c2 == 0) return true;
   unsigned char c1 = (unsigned char)*s1++; if (c1 != c2) return false;
 }
}

bool StringsAreEqualNoCase(const wchar_t *s1, const wchar_t *s2) throw()
{
 for (;;)
 {
   wchar_t c1 = *s1++;
   wchar_t c2 = *s2++;
   if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2)) return false;
   if (c1 == 0) return true;
 }
}

// ---------- ASCII ----------

bool AString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
{
 const char *s1 = _chars;
 for (;;)
 {
   char c2 = *s++;
   if (c2 == 0)
     return true;
   char c1 = *s1++;
   if (MyCharLower_Ascii(c1) !=
       MyCharLower_Ascii(c2))
     return false;
 }
}

bool UString::IsPrefixedBy_Ascii_NoCase(const char *s) const throw()
{
 const wchar_t *s1 = _chars;
 for (;;)
 {
   char c2 = *s++;
   if (c2 == 0)
     return true;
   wchar_t c1 = *s1++;
   if (MyCharLower_Ascii(c1) != (unsigned char)MyCharLower_Ascii(c2))
     return false;
 }
}

bool StringsAreEqual_Ascii(const wchar_t *u, const char *a) throw()
{
 for (;;)
 {
   unsigned char c = *a;
   if (c != *u)
     return false;
   if (c == 0)
     return true;
   a++;
   u++;
 }
}

bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw()
{
 for (;;)
 {
   char c1 = *s1++;
   char c2 = *s2++;
   if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
     return false;
   if (c1 == 0)
     return true;
 }
}

bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw()
{
 for (;;)
 {
   wchar_t c1 = *s1++;
   wchar_t c2 = *s2++;
   if (c1 != c2 && MyCharLower_Ascii(c1) != MyCharLower_Ascii(c2))
     return false;
   if (c1 == 0)
     return true;
 }
}

bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw()
{
 for (;;)
 {
   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)
     return true;
 }
}

bool IsString1PrefixedByString2(const wchar_t *s1, const wchar_t *s2) throw()
{
 for (;;)
 {
   wchar_t c2 = *s2++; if (c2 == 0) return true;
   wchar_t c1 = *s1++; if (c1 != c2) return false;
 }
}

bool IsString1PrefixedByString2(const wchar_t *s1, const char *s2) throw()
{
 for (;;)
 {
   unsigned char c2 = (unsigned char)(*s2++); if (c2 == 0) return true;
   wchar_t c1 = *s1++; if (c1 != c2) return false;
 }
}

bool IsString1PrefixedByString2_NoCase_Ascii(const wchar_t *s1, const char *s2) throw()
{
 for (;;)
 {
   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;
 }
}

bool IsString1PrefixedByString2_NoCase(const wchar_t *s1, const wchar_t *s2) throw()
{
 for (;;)
 {
   wchar_t c2 = *s2++; if (c2 == 0) return true;
   wchar_t c1 = *s1++;
   if (c1 != c2 && MyCharUpper(c1) != MyCharUpper(c2))
     return false;
 }
}

// NTFS order: uses upper case
int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2) throw()
{
 for (;;)
 {
   wchar_t c1 = *s1++;
   wchar_t c2 = *s2++;
   if (c1 != c2)
   {
     wchar_t u1 = MyCharUpper(c1);
     wchar_t u2 = MyCharUpper(c2);
     if (u1 < u2) return -1;
     if (u1 > u2) return 1;
   }
   if (c1 == 0) return 0;
 }
}

/*
int MyStringCompareNoCase_N(const wchar_t *s1, const wchar_t *s2, unsigned num)
{
 for (; num != 0; num--)
 {
   wchar_t c1 = *s1++;
   wchar_t c2 = *s2++;
   if (c1 != c2)
   {
     wchar_t u1 = MyCharUpper(c1);
     wchar_t u2 = MyCharUpper(c2);
     if (u1 < u2) return -1;
     if (u1 > u2) return 1;
   }
   if (c1 == 0) return 0;
 }
 return 0;
}
*/

// ---------- AString ----------

void AString::InsertSpace(unsigned &index, unsigned size)
{
 Grow(size);
 MoveItems(index + size, index);
}

#define k_Alloc_Len_Limit 0x40000000

void AString::ReAlloc(unsigned newLimit)
{
 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;
}

void AString::ReAlloc2(unsigned newLimit)
{
 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);
 _chars = newBuf;
 _limit = newLimit;
}

void AString::SetStartLen(unsigned len)
{
 _chars = 0;
 _chars = MY_STRING_NEW_char(len + 1);
 _len = len;
 _limit = len;
}

void AString::Grow_1()
{
 unsigned next = _len;
 next += next / 2;
 next += 16;
 next &= ~(unsigned)15;
 ReAlloc(next - 1);
}

void AString::Grow(unsigned n)
{
 unsigned freeSize = _limit - _len;
 if (n <= freeSize)
   return;
 
 unsigned next = _len + n;
 next += next / 2;
 next += 16;
 next &= ~(unsigned)15;
 ReAlloc(next - 1);
}

AString::AString(unsigned num, const char *s)
{
 unsigned len = MyStringLen(s);
 if (num > len)
   num = len;
 SetStartLen(num);
 memcpy(_chars, s, num);
 _chars[num] = 0;
}

AString::AString(unsigned num, const AString &s)
{
 if (num > s._len)
   num = s._len;
 SetStartLen(num);
 memcpy(_chars, s._chars, num);
 _chars[num] = 0;
}

AString::AString(const AString &s, char c)
{
 SetStartLen(s.Len() + 1);
 char *chars = _chars;
 unsigned len = s.Len();
 memcpy(chars, s, len);
 chars[len] = c;
 chars[(size_t)len + 1] = 0;
}

AString::AString(const char *s1, unsigned num1, const char *s2, unsigned num2)
{
 SetStartLen(num1 + num2);
 char *chars = _chars;
 memcpy(chars, s1, num1);
 memcpy(chars + num1, s2, num2 + 1);
}

AString operator+(const AString &s1, const AString &s2) { return AString(s1, s1.Len(), s2, s2.Len()); }
AString operator+(const AString &s1, const char    *s2) { return AString(s1, s1.Len(), s2, MyStringLen(s2)); }
AString operator+(const char    *s1, const AString &s2) { return AString(s1, MyStringLen(s1), s2, s2.Len()); }

static const unsigned kStartStringCapacity = 4;

AString::AString()
{
 _chars = 0;
 _chars = MY_STRING_NEW_char(kStartStringCapacity);
 _len = 0;
 _limit = kStartStringCapacity - 1;
 _chars[0] = 0;
}

AString::AString(char c)
{
 SetStartLen(1);
 char *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
}

AString::AString(const char *s)
{
 SetStartLen(MyStringLen(s));
 MyStringCopy(_chars, s);
}

AString::AString(const AString &s)
{
 SetStartLen(s._len);
 MyStringCopy(_chars, s._chars);
}

AString &AString::operator=(char c)
{
 if (1 > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(1 + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = 1;
 }
 _len = 1;
 char *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
 return *this;
}

AString &AString::operator=(const char *s)
{
 unsigned len = MyStringLen(s);
 if (len > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 MyStringCopy(_chars, s);
 return *this;
}

AString &AString::operator=(const AString &s)
{
 if (&s == this)
   return *this;
 unsigned len = s._len;
 if (len > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 MyStringCopy(_chars, s._chars);
 return *this;
}

void AString::SetFromWStr_if_Ascii(const wchar_t *s)
{
 unsigned len = 0;
 {
   for (;; len++)
   {
     wchar_t c = s[len];
     if (c == 0)
       break;
     if (c >= 0x80)
       return;
   }
 }
 if (len > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 char *dest = _chars;
 unsigned i;
 for (i = 0; i < len; i++)
   dest[i] = (char)s[i];
 dest[i] = 0;
}

/*
void AString::SetFromBstr_if_Ascii(BSTR s)
{
 unsigned len = ::SysStringLen(s);
 {
   for (unsigned i = 0; i < len; i++)
     if (s[i] <= 0 || s[i] >= 0x80)
       return;
 }
 if (len > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 char *dest = _chars;
 unsigned i;
 for (i = 0; i < len; i++)
   dest[i] = (char)s[i];
 dest[i] = 0;
}
*/

void AString::Add_Space() { operator+=(' '); }
void AString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
void AString::Add_LF() { operator+=('\n'); }

AString &AString::operator+=(const char *s)
{
 unsigned len = MyStringLen(s);
 Grow(len);
 MyStringCopy(_chars + _len, s);
 _len += len;
 return *this;
}

void AString::Add_OptSpaced(const char *s)
{
 Add_Space_if_NotEmpty();
 (*this) += s;
}

AString &AString::operator+=(const AString &s)
{
 Grow(s._len);
 MyStringCopy(_chars + _len, s._chars);
 _len += s._len;
 return *this;
}

void AString::Add_UInt32(UInt32 v)
{
 char sz[16];
 ConvertUInt32ToString(v, sz);
 (*this) += sz;
}

void AString::SetFrom(const char *s, unsigned len) // no check
{
 if (len > _limit)
 {
   char *newBuf = MY_STRING_NEW_char(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 if (len != 0)
   memcpy(_chars, s, len);
 _chars[len] = 0;
 _len = len;
}

void AString::SetFrom_CalcLen(const char *s, unsigned len) // no check
{
 unsigned i;
 for (i = 0; i < len; i++)
   if (s[i] == 0)
     break;
 SetFrom(s, i);
}

int AString::Find(const char *s, unsigned startIndex) const throw()
{
 const char *fs = strstr(_chars + startIndex, s);
 if (!fs)
   return -1;
 return (int)(fs - _chars);

 /*
 if (s[0] == 0)
   return startIndex;
 unsigned len = MyStringLen(s);
 const char *p = _chars + startIndex;
 for (;; p++)
 {
   const char c = *p;
   if (c != s[0])
   {
     if (c == 0)
       return -1;
     continue;
   }
   unsigned i;
   for (i = 1; i < len; i++)
     if (p[i] != s[i])
       break;
   if (i == len)
     return (int)(p - _chars);
 }
 */
}

int AString::ReverseFind(char c) const throw()
{
 if (_len == 0)
   return -1;
 const char *p = _chars + _len - 1;
 for (;;)
 {
   if (*p == c)
     return (int)(p - _chars);
   if (p == _chars)
     return -1;
   p--; // p = GetPrevCharPointer(_chars, p);
 }
}

int AString::ReverseFind_PathSepar() const throw()
{
 if (_len == 0)
   return -1;
 const char *p = _chars + _len - 1;
 for (;;)
 {
   char c = *p;
   if (IS_PATH_SEPAR(c))
     return (int)(p - _chars);
   if (p == _chars)
     return -1;
   p--;
 }
}

void AString::TrimLeft() throw()
{
 const char *p = _chars;
 for (;; p++)
 {
   char c = *p;
   if (c != ' ' && c != '\n' && c != '\t')
     break;
 }
 unsigned pos = (unsigned)(p - _chars);
 if (pos != 0)
 {
   MoveItems(0, pos);
   _len -= pos;
 }
}

void AString::TrimRight() throw()
{
 const char *p = _chars;
 unsigned i;
 for (i = _len; i != 0; i--)
 {
   char c = p[(size_t)i - 1];
   if (c != ' ' && c != '\n' && c != '\t')
     break;
 }
 if (i != _len)
 {
   _chars[i] = 0;
   _len = i;
 }
}

void AString::InsertAtFront(char c)
{
 if (_limit == _len)
   Grow_1();
 MoveItems(1, 0);
 _chars[0] = c;
 _len++;
}

/*
void AString::Insert(unsigned index, char c)
{
 InsertSpace(index, 1);
 _chars[index] = c;
 _len++;
}
*/

void AString::Insert(unsigned index, const char *s)
{
 unsigned num = MyStringLen(s);
 if (num != 0)
 {
   InsertSpace(index, num);
   memcpy(_chars + index, s, num);
   _len += num;
 }
}

void AString::Insert(unsigned index, const AString &s)
{
 unsigned num = s.Len();
 if (num != 0)
 {
   InsertSpace(index, num);
   memcpy(_chars + index, s, num);
   _len += num;
 }
}

void AString::RemoveChar(char ch) throw()
{
 char *src = _chars;
 
 for (;;)
 {
   char c = *src++;
   if (c == 0)
     return;
   if (c == ch)
     break;
 }

 char *dest = src - 1;
 
 for (;;)
 {
   char c = *src++;
   if (c == 0)
     break;
   if (c != ch)
     *dest++ = c;
 }
 
 *dest = 0;
 _len = (unsigned)(dest - _chars);
}

// !!!!!!!!!!!!!!! test it if newChar = '\0'
void AString::Replace(char oldChar, char newChar) throw()
{
 if (oldChar == newChar)
   return; // 0;
 // unsigned number = 0;
 int pos = 0;
 char *chars = _chars;
 while ((unsigned)pos < _len)
 {
   pos = Find(oldChar, pos);
   if (pos < 0)
     break;
   chars[(unsigned)pos] = newChar;
   pos++;
   // number++;
 }
 return; //  number;
}

void AString::Replace(const AString &oldString, const AString &newString)
{
 if (oldString.IsEmpty())
   return; // 0;
 if (oldString == newString)
   return; // 0;
 unsigned oldLen = oldString.Len();
 unsigned newLen = newString.Len();
 // unsigned number = 0;
 int pos = 0;
 while ((unsigned)pos < _len)
 {
   pos = Find(oldString, pos);
   if (pos < 0)
     break;
   Delete(pos, oldLen);
   Insert(pos, newString);
   pos += newLen;
   // number++;
 }
 // return number;
}

void AString::Delete(unsigned index) throw()
{
 MoveItems(index, index + 1);
 _len--;
}

void AString::Delete(unsigned index, unsigned count) throw()
{
 if (index + count > _len)
   count = _len - index;
 if (count > 0)
 {
   MoveItems(index, index + count);
   _len -= count;
 }
}

void AString::DeleteFrontal(unsigned num) throw()
{
 if (num != 0)
 {
   MoveItems(0, num);
   _len -= num;
 }
}

/*
AString operator+(const AString &s1, const AString &s2)
{
 AString result(s1);
 result += s2;
 return result;
}

AString operator+(const AString &s, const char *chars)
{
 AString result(s);
 result += chars;
 return result;
}

AString operator+(const char *chars, const AString &s)
{
 AString result(chars);
 result += s;
 return result;
}

AString operator+(const AString &s, char c)
{
 AString result(s);
 result += c;
 return result;
}
*/

/*
AString operator+(char c, const AString &s)
{
 AString result(c);
 result += s;
 return result;
}
*/




// ---------- UString ----------

void UString::InsertSpace(unsigned index, unsigned size)
{
 Grow(size);
 MoveItems(index + size, index);
}

void UString::ReAlloc(unsigned newLimit)
{
 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);
 _chars = newBuf;
 _limit = newLimit;
}

void UString::ReAlloc2(unsigned 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(newLimit + 1);
 newBuf[0] = 0;
 MY_STRING_DELETE(_chars);
 _chars = newBuf;
 _limit = newLimit;
}

void UString::SetStartLen(unsigned len)
{
 _chars = 0;
 _chars = MY_STRING_NEW_wchar_t(len + 1);
 _len = len;
 _limit = len;
}

void UString::Grow_1()
{
 unsigned next = _len;
 next += next / 2;
 next += 16;
 next &= ~(unsigned)15;
 ReAlloc(next - 1);
}

void UString::Grow(unsigned n)
{
 unsigned freeSize = _limit - _len;
 if (n <= freeSize)
   return;
 
 unsigned next = _len + n;
 next += next / 2;
 next += 16;
 next &= ~(unsigned)15;
 ReAlloc(next - 1);
}


UString::UString(unsigned num, const wchar_t *s)
{
 unsigned len = MyStringLen(s);
 if (num > len)
   num = len;
 SetStartLen(num);
 wmemcpy(_chars, s, num);
 _chars[num] = 0;
}


UString::UString(unsigned num, const UString &s)
{
 if (num > s._len)
   num = s._len;
 SetStartLen(num);
 wmemcpy(_chars, s._chars, num);
 _chars[num] = 0;
}

UString::UString(const UString &s, wchar_t c)
{
 SetStartLen(s.Len() + 1);
 wchar_t *chars = _chars;
 unsigned len = s.Len();
 wmemcpy(chars, s, len);
 chars[len] = c;
 chars[(size_t)len + 1] = 0;
}

UString::UString(const wchar_t *s1, unsigned num1, const wchar_t *s2, unsigned num2)
{
 SetStartLen(num1 + num2);
 wchar_t *chars = _chars;
 wmemcpy(chars, s1, num1);
 wmemcpy(chars + num1, s2, num2 + 1);
}

UString operator+(const UString &s1, const UString &s2) { return UString(s1, s1.Len(), s2, s2.Len()); }
UString operator+(const UString &s1, const wchar_t *s2) { return UString(s1, s1.Len(), s2, MyStringLen(s2)); }
UString operator+(const wchar_t *s1, const UString &s2) { return UString(s1, MyStringLen(s1), s2, s2.Len()); }

UString::UString()
{
 _chars = 0;
 _chars = MY_STRING_NEW_wchar_t(kStartStringCapacity);
 _len = 0;
 _limit = kStartStringCapacity - 1;
 _chars[0] = 0;
}

UString::UString(wchar_t c)
{
 SetStartLen(1);
 wchar_t *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
}

UString::UString(char c)
{
 SetStartLen(1);
 wchar_t *chars = _chars;
 chars[0] = (unsigned char)c;
 chars[1] = 0;
}

UString::UString(const wchar_t *s)
{
 unsigned len = MyStringLen(s);
 SetStartLen(len);
 wmemcpy(_chars, s, len + 1);
}

UString::UString(const char *s)
{
 unsigned len = MyStringLen(s);
 SetStartLen(len);
 wchar_t *chars = _chars;
 for (unsigned i = 0; i < len; i++)
   chars[i] = (unsigned char)s[i];
 chars[len] = 0;
}

UString::UString(const UString &s)
{
 SetStartLen(s._len);
 wmemcpy(_chars, s._chars, s._len + 1);
}

UString &UString::operator=(wchar_t c)
{
 if (1 > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = 1;
 }
 _len = 1;
 wchar_t *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
 return *this;
}

UString &UString::operator=(const wchar_t *s)
{
 unsigned len = MyStringLen(s);
 if (len > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 wmemcpy(_chars, s, len + 1);
 return *this;
}

UString &UString::operator=(const UString &s)
{
 if (&s == this)
   return *this;
 unsigned len = s._len;
 if (len > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 wmemcpy(_chars, s._chars, len + 1);
 return *this;
}

void UString::SetFrom(const wchar_t *s, unsigned len) // no check
{
 if (len > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 if (len != 0)
   wmemcpy(_chars, s, len);
 _chars[len] = 0;
 _len = len;
}

void UString::SetFromBstr(BSTR s)
{
 unsigned len = ::SysStringLen(s);
 if (len > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 _len = len;
 // if (s)
   wmemcpy(_chars, s, len + 1);
}

UString &UString::operator=(const char *s)
{
 unsigned len = MyStringLen(s);
 if (len > _limit)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   MY_STRING_DELETE(_chars);
   _chars = newBuf;
   _limit = len;
 }
 wchar_t *chars = _chars;
 for (unsigned i = 0; i < len; i++)
   chars[i] = (unsigned char)s[i];
 chars[len] = 0;
 _len = len;
 return *this;
}

void UString::Add_Space() { operator+=(L' '); }
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);
 Grow(len);
 wmemcpy(_chars + _len, s, len + 1);
 _len += len;
 return *this;
}

UString &UString::operator+=(const UString &s)
{
 Grow(s._len);
 wmemcpy(_chars + _len, s._chars, s._len + 1);
 _len += s._len;
 return *this;
}

UString &UString::operator+=(const char *s)
{
 unsigned len = MyStringLen(s);
 Grow(len);
 wchar_t *chars = _chars + _len;
 for (unsigned i = 0; i < len; i++)
   chars[i] = (unsigned char)s[i];
 chars[len] = 0;
 _len += len;
 return *this;
}


void UString::Add_UInt32(UInt32 v)
{
 char sz[16];
 ConvertUInt32ToString(v, sz);
 (*this) += sz;
}


int UString::Find(const wchar_t *s, unsigned startIndex) const throw()
{
 const wchar_t *fs = wcsstr(_chars + startIndex, s);
 if (!fs)
   return -1;
 return (int)(fs - _chars);

 /*
 if (s[0] == 0)
   return startIndex;
 unsigned len = MyStringLen(s);
 const wchar_t *p = _chars + startIndex;
 for (;; p++)
 {
   const wchar_t c = *p;
   if (c != s[0])
   {
     if (c == 0)
       return -1;
     continue;
   }
   unsigned i;
   for (i = 1; i < len; i++)
     if (p[i] != s[i])
       break;
   if (i == len)
     return (int)(p - _chars);
 }
 */
}

int UString::ReverseFind(wchar_t c) const throw()
{
 if (_len == 0)
   return -1;
 const wchar_t *p = _chars + _len - 1;
 for (;;)
 {
   if (*p == c)
     return (int)(p - _chars);
   if (p == _chars)
     return -1;
   p--;
 }
}

int UString::ReverseFind_PathSepar() const throw()
{
 if (_len == 0)
   return -1;
 const wchar_t *p = _chars + _len - 1;
 for (;;)
 {
   wchar_t c = *p;
   if (IS_PATH_SEPAR(c))
     return (int)(p - _chars);
   if (p == _chars)
     return -1;
   p--;
 }
}

void UString::TrimLeft() throw()
{
 const wchar_t *p = _chars;
 for (;; p++)
 {
   wchar_t c = *p;
   if (c != ' ' && c != '\n' && c != '\t')
     break;
 }
 unsigned pos = (unsigned)(p - _chars);
 if (pos != 0)
 {
   MoveItems(0, pos);
   _len -= pos;
 }
}

void UString::TrimRight() throw()
{
 const wchar_t *p = _chars;
 unsigned i;
 for (i = _len; i != 0; i--)
 {
   wchar_t c = p[(size_t)i - 1];
   if (c != ' ' && c != '\n' && c != '\t')
     break;
 }
 if (i != _len)
 {
   _chars[i] = 0;
   _len = i;
 }
}

void UString::InsertAtFront(wchar_t c)
{
 if (_limit == _len)
   Grow_1();
 MoveItems(1, 0);
 _chars[0] = c;
 _len++;
}

/*
void UString::Insert(unsigned index, wchar_t c)
{
 InsertSpace(index, 1);
 _chars[index] = c;
 _len++;
}
*/

void UString::Insert(unsigned index, const wchar_t *s)
{
 unsigned num = MyStringLen(s);
 if (num != 0)
 {
   InsertSpace(index, num);
   wmemcpy(_chars + index, s, num);
   _len += num;
 }
}

void UString::Insert(unsigned index, const UString &s)
{
 unsigned num = s.Len();
 if (num != 0)
 {
   InsertSpace(index, num);
   wmemcpy(_chars + index, s, num);
   _len += num;
 }
}

void UString::RemoveChar(wchar_t ch) throw()
{
 wchar_t *src = _chars;
 
 for (;;)
 {
   wchar_t c = *src++;
   if (c == 0)
     return;
   if (c == ch)
     break;
 }

 wchar_t *dest = src - 1;
 
 for (;;)
 {
   wchar_t c = *src++;
   if (c == 0)
     break;
   if (c != ch)
     *dest++ = c;
 }
 
 *dest = 0;
 _len = (unsigned)(dest - _chars);
}

// !!!!!!!!!!!!!!! test it if newChar = '\0'
void UString::Replace(wchar_t oldChar, wchar_t newChar) throw()
{
 if (oldChar == newChar)
   return; // 0;
 // unsigned number = 0;
 int pos = 0;
 wchar_t *chars = _chars;
 while ((unsigned)pos < _len)
 {
   pos = Find(oldChar, pos);
   if (pos < 0)
     break;
   chars[(unsigned)pos] = newChar;
   pos++;
   // number++;
 }
 return; //  number;
}

void UString::Replace(const UString &oldString, const UString &newString)
{
 if (oldString.IsEmpty())
   return; // 0;
 if (oldString == newString)
   return; // 0;
 unsigned oldLen = oldString.Len();
 unsigned newLen = newString.Len();
 // unsigned number = 0;
 int pos = 0;
 while ((unsigned)pos < _len)
 {
   pos = Find(oldString, pos);
   if (pos < 0)
     break;
   Delete(pos, oldLen);
   Insert(pos, newString);
   pos += newLen;
   // number++;
 }
 // return number;
}

void UString::Delete(unsigned index) throw()
{
 MoveItems(index, index + 1);
 _len--;
}

void UString::Delete(unsigned index, unsigned count) throw()
{
 if (index + count > _len)
   count = _len - index;
 if (count > 0)
 {
   MoveItems(index, index + count);
   _len -= count;
 }
}

void UString::DeleteFrontal(unsigned num) throw()
{
 if (num != 0)
 {
   MoveItems(0, num);
   _len -= num;
 }
}


// ---------- UString2 ----------

void UString2::ReAlloc2(unsigned newLimit)
{
 if (newLimit >= k_Alloc_Len_Limit) throw 20130221;
 // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
 _chars = MY_STRING_NEW_wchar_t(newLimit + 1);
}

void UString2::SetStartLen(unsigned len)
{
 _chars = 0;
 _chars = MY_STRING_NEW_wchar_t(len + 1);
 _len = len;
}


/*
UString2::UString2(wchar_t c)
{
 SetStartLen(1);
 wchar_t *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
}
*/

UString2::UString2(const wchar_t *s)
{
 unsigned len = MyStringLen(s);
 SetStartLen(len);
 wmemcpy(_chars, s, len + 1);
}

UString2::UString2(const UString2 &s): _chars(NULL), _len(0)
{
 if (s._chars)
 {
   SetStartLen(s._len);
   wmemcpy(_chars, s._chars, s._len + 1);
 }
}

/*
UString2 &UString2::operator=(wchar_t c)
{
 if (1 > _len)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(1 + 1);
   if (_chars)
     MY_STRING_DELETE(_chars);
   _chars = newBuf;
 }
 _len = 1;
 wchar_t *chars = _chars;
 chars[0] = c;
 chars[1] = 0;
 return *this;
}
*/

UString2 &UString2::operator=(const wchar_t *s)
{
 unsigned len = MyStringLen(s);
 if (len > _len)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   if (_chars)
     MY_STRING_DELETE(_chars);
   _chars = newBuf;
 }
 _len = len;
 MyStringCopy(_chars, s);
 return *this;
}

void UString2::SetFromAscii(const char *s)
{
 unsigned len = MyStringLen(s);
 if (len > _len)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   if (_chars)
     MY_STRING_DELETE(_chars);
   _chars = newBuf;
 }
 wchar_t *chars = _chars;
 for (unsigned i = 0; i < len; i++)
   chars[i] = (unsigned char)s[i];
 chars[len] = 0;
 _len = len;
}

UString2 &UString2::operator=(const UString2 &s)
{
 if (&s == this)
   return *this;
 unsigned len = s._len;
 if (len > _len)
 {
   wchar_t *newBuf = MY_STRING_NEW_wchar_t(len + 1);
   if (_chars)
     MY_STRING_DELETE(_chars);
   _chars = newBuf;
 }
 _len = len;
 MyStringCopy(_chars, s._chars);
 return *this;
}

bool operator==(const UString2 &s1, const UString2 &s2)
{
 return s1.Len() == s2.Len() && (s1.IsEmpty() || wcscmp(s1.GetRawPtr(), s2.GetRawPtr()) == 0);
}

bool operator==(const UString2 &s1, const wchar_t *s2)
{
 if (s1.IsEmpty())
   return (*s2 == 0);
 return wcscmp(s1.GetRawPtr(), s2) == 0;
}

bool operator==(const wchar_t *s1, const UString2 &s2)
{
 if (s2.IsEmpty())
   return (*s1 == 0);
 return wcscmp(s1, s2.GetRawPtr()) == 0;
}



// ----------------------------------------

/*
int MyStringCompareNoCase(const char *s1, const char *s2)
{
 return MyStringCompareNoCase(MultiByteToUnicodeString(s1), MultiByteToUnicodeString(s2));
}
*/

static inline UINT GetCurrentCodePage()
{
 #if defined(UNDER_CE) || !defined(_WIN32)
 return CP_ACP;
 #else
 return ::AreFileApisANSI() ? CP_ACP : CP_OEMCP;
 #endif
}

#ifdef USE_UNICODE_FSTRING

#ifndef _UNICODE

AString fs2fas(CFSTR s)
{
 return UnicodeStringToMultiByte(s, GetCurrentCodePage());
}

FString fas2fs(const char *s)
{
 return MultiByteToUnicodeString(s, GetCurrentCodePage());
}

FString fas2fs(const AString &s)
{
 return MultiByteToUnicodeString(s, GetCurrentCodePage());
}

#endif

#else

UString fs2us(const FChar *s)
{
 return MultiByteToUnicodeString(s, GetCurrentCodePage());
}

UString fs2us(const FString &s)
{
 return MultiByteToUnicodeString(s, GetCurrentCodePage());
}

FString us2fs(const wchar_t *s)
{
 return UnicodeStringToMultiByte(s, GetCurrentCodePage());
}

#endif