4.59 beta

2025-12-07 20:06:59 -06:00 · 2008-08-13 00:00:00 +00:00
parent 3901bf0ab8
commit 173c07e166
781 changed files with 22124 additions and 13650 deletions
--- a/CPP/Common/AutoPtr.h
+++ b/CPP/Common/AutoPtr.h
@@ -9,7 +9,7 @@ template<class T> class CMyAutoPtr
 public:
  CMyAutoPtr(T *p = 0) : _p(p) {}
  CMyAutoPtr(CMyAutoPtr<T>& p): _p(p.release()) {}
-  CMyAutoPtr<T>& operator=(CMyAutoPtr<T>& p) 
+  CMyAutoPtr<T>& operator=(CMyAutoPtr<T>& p)
  {
    reset(p.release());
    return (*this);
--- a/CPP/Common/Buffer.h
+++ b/CPP/Common/Buffer.h
@@ -6,7 +6,7 @@
 #include "Defs.h"

 template <class T> class CBuffer
-{    
+{
 protected:
  size_t _capacity;
  T *_items;
--- a/CPP/Common/CRC.cpp
+++ b/CPP/Common/CRC.cpp
@@ -2,8 +2,8 @@

 #include "StdAfx.h"

-extern "C" 
-{ 
+extern "C"
+{
 #include "../../C/7zCrc.h"
 }

--- a/CPP/Common/CommandLineParser.cpp
+++ b/CPP/Common/CommandLineParser.cpp
@@ -22,7 +22,7 @@ void SplitCommandLine(const UString &src, UString &dest1, UString &dest2)
      i++;
      break;
    }
-    else 
+    else
      dest1 += c;
  }
  dest2 = src.Mid(i);
@@ -55,8 +55,8 @@ static const wchar_t kSwitchMinus = '-';
 static const wchar_t *kStopSwitchParsing = L"--";

 static bool IsItSwitchChar(wchar_t c)
-{ 
-  return (c == kSwitchID1 /*|| c == kSwitchID2 */); 
+{
+  return (c == kSwitchID1 /*|| c == kSwitchID2 */);
 }

 CParser::CParser(int numSwitches):
@@ -70,7 +70,7 @@ CParser::~CParser()
  delete []_switches;
 }

-void CParser::ParseStrings(const CSwitchForm *switchForms, 
+void CParser::ParseStrings(const CSwitchForm *switchForms,
  const UStringVector &commandStrings)
 {
  int numCommandStrings = commandStrings.Size();
@@ -94,7 +94,7 @@ void CParser::ParseStrings(const CSwitchForm *switchForms,
 bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
 {
  int len = s.Length();
-  if (len == 0) 
+  if (len == 0)
    return false;
  int pos = 0;
  if (!IsItSwitchChar(s[pos]))
@@ -109,7 +109,7 @@ bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
    for(int switchIndex = 0; switchIndex < _numSwitches; switchIndex++)
    {
      int switchLen = MyStringLen(switchForms[switchIndex].IDString);
-      if (switchLen <= maxLen || pos + switchLen > len) 
+      if (switchLen <= maxLen || pos + switchLen > len)
        continue;

      UString temp = s + pos;
@@ -166,8 +166,8 @@ bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
          }
          break;
        }
-      case NSwitchType::kLimitedPostString: 
-      case NSwitchType::kUnLimitedPostString: 
+      case NSwitchType::kLimitedPostString:
+      case NSwitchType::kUnLimitedPostString:
        {
          int minLen = switchForm.MinLen;
          if (tailSize < minLen)
@@ -205,7 +205,7 @@ const CSwitchResult& CParser::operator[](size_t index) const
 /////////////////////////////////
 // Command parsing procedures

-int ParseCommand(int numCommandForms, const CCommandForm *commandForms, 
+int ParseCommand(int numCommandForms, const CCommandForm *commandForms,
    const UString &commandString, UString &postString)
 {
  for(int i = 0; i < numCommandForms; i++)
--- a/CPP/Common/CommandLineParser.h
+++ b/CPP/Common/CommandLineParser.h
@@ -12,7 +12,7 @@ void SplitCommandLine(const UString &s, UStringVector &parts);

 namespace NSwitchType {
  enum EEnum
-  { 
+  {
    kSimple,
    kPostMinus,
    kLimitedPostString,
@@ -44,12 +44,12 @@ class CParser
 {
  int _numSwitches;
  CSwitchResult *_switches;
-  bool ParseString(const UString &s, const CSwitchForm *switchForms); 
+  bool ParseString(const UString &s, const CSwitchForm *switchForms);
 public:
  UStringVector NonSwitchStrings;
  CParser(int numSwitches);
  ~CParser();
-  void ParseStrings(const CSwitchForm *switchForms, 
+  void ParseStrings(const CSwitchForm *switchForms,
    const UStringVector &commandStrings);
  const CSwitchResult& operator[](size_t index) const;
 };
@@ -64,7 +64,7 @@ struct CCommandForm
 };

 // Returns: Index of form and postString; -1, if there is no match
-int ParseCommand(int numCommandForms, const CCommandForm *commandForms, 
+int ParseCommand(int numCommandForms, const CCommandForm *commandForms,
    const UString &commandString, UString &postString);

 }
--- a/CPP/Common/DynamicBuffer.h
+++ b/CPP/Common/DynamicBuffer.h
@@ -6,7 +6,7 @@
 #include "Buffer.h"

 template <class T> class CDynamicBuffer: public CBuffer<T>
-{    
+{
  void GrowLength(size_t size)
  {
    size_t delta;
--- a/CPP/Common/IntToString.cpp
+++ b/CPP/Common/IntToString.cpp
@@ -13,7 +13,7 @@ void ConvertUInt64ToString(UInt64 value, char *s, UInt32 base)
  }
  char temp[72];
  int pos = 0;
-  do 
+  do
  {
    int delta = (int)(value % base);
    temp[pos++] = (char)((delta < 10) ? ('0' + delta) : ('a' + (delta - 10)));
@@ -30,13 +30,13 @@ void ConvertUInt64ToString(UInt64 value, wchar_t *s)
 {
  wchar_t temp[32];
  int pos = 0;
-  do 
+  do
  {
    temp[pos++] = (wchar_t)(L'0' + (int)(value % 10));
    value /= 10;
  }
  while (value != 0);
-  do 
+  do
    *s++ = temp[--pos];
  while(pos > 0);
  *s = L'\0';
--- a/CPP/Common/Lang.cpp
+++ b/CPP/Common/Lang.cpp
@@ -105,7 +105,7 @@ bool CLang::Open(LPCWSTR fileName)

 int CLang::FindItem(UInt32 value) const
 {
-  int left = 0, right = _langPairs.Size(); 
+  int left = 0, right = _langPairs.Size();
  while (left != right)
  {
    UInt32 mid = (left + right) / 2;
--- a/CPP/Common/MyCom.h
+++ b/CPP/Common/MyCom.h
@@ -28,11 +28,11 @@ public:
  // T& operator*() const {  return *_p; }
  T** operator&() { return &_p; }
  T* operator->() const { return _p; }
-  T* operator=(T* p) 
-  { 
+  T* operator=(T* p)
+  {
    if (p != 0)
      p->AddRef();
-    if (_p) 
+    if (_p)
      _p->Release();
    _p = p;
    return p;
@@ -116,8 +116,8 @@ public:
  unsigned int Length() const { return ::SysStringLen(m_str); }
  operator BSTR() const { return m_str; }
  BSTR* operator&() { return &m_str; }
-  BSTR MyCopy() const 
-  { 
+  BSTR MyCopy() const
+  {
    int byteLen = ::SysStringByteLen(m_str);
    BSTR res = ::SysAllocStringByteLen(NULL, byteLen);
    memmove(res, m_str, byteLen);
@@ -149,7 +149,7 @@ public:
 };

 #define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \
-    (REFGUID iid, void **outObject) { 
+    (REFGUID iid, void **outObject) {

 #define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \
    { *outObject = (void *)(i *)this; AddRef(); return S_OK; }
--- a/CPP/Common/MyGuidDef.h
+++ b/CPP/Common/MyGuidDef.h
@@ -23,7 +23,7 @@ typedef struct {

 #ifdef __cplusplus
 inline int operator==(REFGUID g1, REFGUID g2)
-{ 
+{
  for (int i = 0; i < (int)sizeof(g1); i++)
    if (((unsigned char *)&g1)[i] != ((unsigned char *)&g2)[i])
      return 0;
--- a/CPP/Common/MyMap.cpp
+++ b/CPP/Common/MyMap.cpp
@@ -0,0 +1,140 @@
+// MyMap.cpp
+
+#include "StdAfx.h"
+
+#include "MyMap.h"
+
+static const unsigned kNumBitsMax = sizeof(UInt32) * 8;
+
+static UInt32 GetSubBits(UInt32 value, unsigned startPos, unsigned numBits)
+{
+  if (startPos == sizeof(value) * 8)
+    return 0;
+  value >>= startPos;
+  if (numBits == sizeof(value) * 8)
+    return value;
+  return value & (((UInt32)1 << numBits) - 1);
+}
+
+static inline unsigned GetSubBit(UInt32 v, unsigned n) { return (unsigned)(v >> n) & 1; }
+
+bool CMap32::Find(UInt32 key, UInt32 &valueRes) const
+{
+  valueRes = (UInt32)(Int32)-1;
+  if (Nodes.Size() == 0)
+    return false;
+  if (Nodes.Size() == 1)
+  {
+    const CNode &n = Nodes[0];
+    if (n.Len == kNumBitsMax)
+    {
+      valueRes = n.Values[0];
+      return (key == n.Key);
+    }
+  }
+
+  int cur = 0;
+  unsigned bitPos = kNumBitsMax;
+  for (;;)
+  {
+    const CNode &n = Nodes[cur];
+    bitPos -= n.Len;
+    if (GetSubBits(key, bitPos, n.Len) != GetSubBits(n.Key, bitPos, n.Len))
+      return false;
+    unsigned bit = GetSubBit(key, --bitPos);
+    if (n.IsLeaf[bit])
+    {
+      valueRes = n.Values[bit];
+      return (key == n.Keys[bit]);
+    }
+    cur = (int)n.Keys[bit];
+  }
+}
+
+bool CMap32::Set(UInt32 key, UInt32 value)
+{
+  if (Nodes.Size() == 0)
+  {
+    CNode n;
+    n.Key = n.Keys[0] = n.Keys[1] = key;
+    n.Values[0] = n.Values[1] = value;
+    n.IsLeaf[0] = n.IsLeaf[1] = 1;
+    n.Len = kNumBitsMax;
+    Nodes.Add(n);
+    return false;
+  }
+  if (Nodes.Size() == 1)
+  {
+    CNode &n = Nodes[0];
+    if (n.Len == kNumBitsMax)
+    {
+      if (key == n.Key)
+      {
+        n.Values[0] = n.Values[1] = value;
+        return true;
+      }
+      unsigned i = kNumBitsMax - 1;
+      for (;GetSubBit(key, i) == GetSubBit(n.Key, i); i--);
+      n.Len = (UInt16)(kNumBitsMax - (1 + i));
+      unsigned newBit = GetSubBit(key, i);
+      n.Values[newBit] = value;
+      n.Keys[newBit] = key;
+      return false;
+    }
+  }
+
+  int cur = 0;
+  unsigned bitPos = kNumBitsMax;
+  for (;;)
+  {
+    CNode &n = Nodes[cur];
+    bitPos -= n.Len;
+    if (GetSubBits(key, bitPos, n.Len) != GetSubBits(n.Key, bitPos, n.Len))
+    {
+      unsigned i = n.Len - 1;
+      for (; GetSubBit(key, bitPos + i) == GetSubBit(n.Key, bitPos + i); i--);
+      
+      CNode e2(n);
+      e2.Len = (UInt16)i;
+
+      n.Len = (UInt16)(n.Len - (1 + i));
+      unsigned newBit = GetSubBit(key, bitPos + i);
+      n.Values[newBit] = value;
+      n.IsLeaf[newBit] = 1;
+      n.IsLeaf[1 - newBit] = 0;
+      n.Keys[newBit] = key;
+      n.Keys[1 - newBit] = Nodes.Size();
+      Nodes.Add(e2);
+      return false;
+    }
+    unsigned bit = GetSubBit(key, --bitPos);
+
+    if (n.IsLeaf[bit])
+    {
+      if (key == n.Keys[bit])
+      {
+        n.Values[bit] = value;
+        return true;
+      }
+      unsigned i = bitPos - 1;
+      for (;GetSubBit(key, i) == GetSubBit(n.Keys[bit], i); i--);
+     
+      CNode e2;
+      
+      unsigned newBit = GetSubBit(key, i);
+      e2.Values[newBit] = value;
+      e2.Values[1 - newBit] = n.Values[bit];
+      e2.IsLeaf[newBit] = e2.IsLeaf[1 - newBit] = 1;
+      e2.Keys[newBit] = key;
+      e2.Keys[1 - newBit] = e2.Key = n.Keys[bit];
+      e2.Len = (UInt16)(bitPos - (1 + i));
+
+      n.IsLeaf[bit] = 0;
+      n.Keys[bit] = Nodes.Size();
+
+      Nodes.Add(e2);
+      return false;
+    }
+    cur = (int)n.Keys[bit];
+  }
+}
--- a/CPP/Common/MyMap.h
+++ b/CPP/Common/MyMap.h
@@ -0,0 +1,28 @@
+// MyMap.h
+
+#ifndef __COMMON_MYMAP_H
+#define __COMMON_MYMAP_H
+
+#include "MyVector.h"
+#include "Types.h"
+
+class CMap32
+{
+  struct CNode
+  {
+    UInt32 Key;
+    UInt32 Keys[2];
+    UInt32 Values[2];
+    UInt16 Len;
+    Byte IsLeaf[2];
+  };
+  CRecordVector<CNode> Nodes;
+
+public:
+
+  void Clear() { Nodes.Clear(); }
+  bool Find(UInt32 key, UInt32 &valueRes) const;
+  bool Set(UInt32 key, UInt32 value); // returns true, if there is such key already
+};
+
+#endif
--- a/CPP/Common/MyString.cpp
+++ b/CPP/Common/MyString.cpp
@@ -64,7 +64,7 @@ wchar_t * MyStringUpper(wchar_t *s)
 }

 wchar_t * MyStringLower(wchar_t *s)
-{ 
+{
  if (s == 0)
    return 0;
  wchar_t *res = CharLowerW(s);
@@ -81,43 +81,43 @@ wchar_t * MyStringLower(wchar_t *s)
 inline int ConvertCompareResult(int r) { return r - 2; }

 int MyStringCollate(const wchar_t *s1, const wchar_t *s2)
-{ 
+{
  int res = CompareStringW(
-        LOCALE_USER_DEFAULT, SORT_STRINGSORT, s1, -1, s2, -1); 
+        LOCALE_USER_DEFAULT, SORT_STRINGSORT, s1, -1, s2, -1);
  #ifdef _UNICODE
  return ConvertCompareResult(res);
  #else
  if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
    return ConvertCompareResult(res);
-  return MyStringCollate(UnicodeStringToMultiByte(s1), 
+  return MyStringCollate(UnicodeStringToMultiByte(s1),
        UnicodeStringToMultiByte(s2));
  #endif
 }

 #ifndef _WIN32_WCE
 int MyStringCollate(const char *s1, const char *s2)
-{ 
+{
  return ConvertCompareResult(CompareStringA(
-    LOCALE_USER_DEFAULT, SORT_STRINGSORT, s1, -1, s2, -1)); 
+    LOCALE_USER_DEFAULT, SORT_STRINGSORT, s1, -1, s2, -1));
 }

 int MyStringCollateNoCase(const char *s1, const char *s2)
-{ 
+{
  return ConvertCompareResult(CompareStringA(
-    LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT, s1, -1, s2, -1)); 
+    LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT, s1, -1, s2, -1));
 }
 #endif

 int MyStringCollateNoCase(const wchar_t *s1, const wchar_t *s2)
-{ 
+{
  int res = CompareStringW(
-        LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT, s1, -1, s2, -1); 
+        LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT, s1, -1, s2, -1);
  #ifdef _UNICODE
  return ConvertCompareResult(res);
  #else
  if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
    return ConvertCompareResult(res);
-  return MyStringCollateNoCase(UnicodeStringToMultiByte(s1), 
+  return MyStringCollateNoCase(UnicodeStringToMultiByte(s1),
      UnicodeStringToMultiByte(s2));
  #endif
 }
@@ -132,7 +132,7 @@ wchar_t MyCharUpper(wchar_t c)

 /*
 int MyStringCollateNoCase(const wchar_t *s1, const wchar_t *s2)
-{ 
+{
  for (;;)
  {
    wchar_t c1 = *s1++;
@@ -150,7 +150,7 @@ int MyStringCollateNoCase(const wchar_t *s1, const wchar_t *s2)
 #endif

 int MyStringCompare(const char *s1, const char *s2)
-{ 
+{
  for (;;)
  {
    unsigned char c1 = (unsigned char)*s1++;
@@ -162,7 +162,7 @@ int MyStringCompare(const char *s1, const char *s2)
 }

 int MyStringCompare(const wchar_t *s1, const wchar_t *s2)
-{ 
+{
  for (;;)
  {
    wchar_t c1 = *s1++;
@@ -174,7 +174,7 @@ int MyStringCompare(const wchar_t *s1, const wchar_t *s2)
 }

 int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2)
-{ 
+{
  for (;;)
  {
    wchar_t c1 = *s1++;
@@ -192,7 +192,7 @@ int MyStringCompareNoCase(const wchar_t *s1, const wchar_t *s2)

 #ifdef _WIN32
 int MyStringCompareNoCase(const char *s1, const char *s2)
-{ 
+{
  return MyStringCompareNoCase(MultiByteToUnicodeString(s1), MultiByteToUnicodeString(s2));
 }
 #endif
--- a/CPP/Common/MyString.h
+++ b/CPP/Common/MyString.h
@@ -14,7 +14,7 @@

 template <class T>
 inline int MyStringLen(const T *s)
-{ 
+{
  int i;
  for (i = 0; s[i] != '\0'; i++);
  return i;
@@ -22,7 +22,7 @@ inline int MyStringLen(const T *s)

 template <class T>
 inline T * MyStringCopy(T *dest, const T *src)
-{ 
+{
  T *destStart = dest;
  while((*dest++ = *src++) != 0);
  return destStart;
@@ -140,7 +140,7 @@ class CStringBase
  }
  void MoveItems(int destIndex, int srcIndex)
  {
-    memmove(_chars + destIndex, _chars + srcIndex, 
+    memmove(_chars + destIndex, _chars + srcIndex,
        sizeof(T) * (_length - srcIndex + 1));
  }
  
@@ -167,7 +167,7 @@ protected:
  void SetCapacity(int newCapacity)
  {
    int realCapacity = newCapacity + 1;
-    if(realCapacity == _capacity)
+    if (realCapacity == _capacity)
      return;
    /*
    const int kMaxStringSize = 0x20000000;
@@ -177,25 +177,21 @@ protected:
    #endif
    */
    T *newBuffer = new T[realCapacity];
-    if(_capacity > 0)
+    if (_capacity > 0)
    {
-      for (int i = 0; i < (_length + 1); i++)
+      for (int i = 0; i < _length; i++)
        newBuffer[i] = _chars[i];
      delete []_chars;
-      _chars = newBuffer;
-    }
-    else
-    {
-      _chars = newBuffer;
-      _chars[0] = 0;
    }
+    _chars = newBuffer;
+    _chars[_length] = 0;
    _capacity = realCapacity;
  }

  void GrowLength(int n)
  {
    int freeSize = _capacity - _length - 1;
-    if (n <= freeSize) 
+    if (n <= freeSize)
      return;
    int delta;
    if (_capacity > 64)
@@ -216,8 +212,7 @@ protected:
  }

 public:
-  CStringBase(): _chars(0), _length(0), _capacity(0)
-    { SetCapacity(16 - 1); }
+  CStringBase(): _chars(0), _length(0), _capacity(0) { SetCapacity(3); }
  CStringBase(T c):  _chars(0), _length(0), _capacity(0)
  {
    SetCapacity(1);
@@ -240,14 +235,14 @@ public:
  }
  ~CStringBase() {  delete []_chars; }

-  operator const T*() const { return _chars;} 
+  operator const T*() const { return _chars;}

-  // The minimum size of the character buffer in characters. 
+  // The minimum size of the character buffer in characters.
  // This value does not include space for a null terminator.
  T* GetBuffer(int minBufLength)
  {
-    if(minBufLength >= _capacity)
-      SetCapacity(minBufLength + 1);
+    if (minBufLength >= _capacity)
+      SetCapacity(minBufLength);
    return _chars;
  }
  void ReleaseBuffer() { ReleaseBuffer(MyStringLen(_chars)); }
@@ -278,9 +273,9 @@ public:
    int length = MyStringLen(chars);
    SetCapacity(length);
    MyStringCopy(_chars, chars);
-    _length = length; 
+    _length = length;
    return *this;
-  }  
+  }
  CStringBase& operator=(const CStringBase& s)
  {
    if(&s == this)
@@ -508,7 +503,7 @@ public:
    while (pos < Length())
    {
      pos = Find(oldChar, pos);
-      if (pos < 0) 
+      if (pos < 0)
        break;
      _chars[pos] = newChar;
      pos++;
@@ -529,7 +524,7 @@ public:
    while (pos < _length)
    {
      pos = Find(oldString, pos);
-      if (pos < 0) 
+      if (pos < 0)
        break;
      Delete(pos, oldStringLength);
      Insert(pos, newString);
@@ -556,7 +551,7 @@ CStringBase<T> operator+(const CStringBase<T>& s1, const CStringBase<T>& s2)
 {
  CStringBase<T> result(s1);
  result += s2;
-  return result; 
+  return result;
 }

 template <class T>
@@ -564,7 +559,7 @@ CStringBase<T> operator+(const CStringBase<T>& s, T c)
 {
  CStringBase<T> result(s);
  result += c;
-  return result; 
+  return result;
 }

 template <class T>
@@ -572,7 +567,7 @@ CStringBase<T> operator+(T c, const CStringBase<T>& s)
 {
  CStringBase<T> result(c);
  result += s;
-  return result; 
+  return result;
 }

 template <class T>
@@ -580,7 +575,7 @@ CStringBase<T> operator+(const CStringBase<T>& s, const T * chars)
 {
  CStringBase<T> result(s);
  result += chars;
-  return result; 
+  return result;
 }

 template <class T>
@@ -588,7 +583,7 @@ CStringBase<T> operator+(const T * chars, const CStringBase<T>& s)
 {
  CStringBase<T> result(chars);
  result += s;
-  return result; 
+  return result;
 }

 template <class T>
--- a/CPP/Common/MyUnknown.h
+++ b/CPP/Common/MyUnknown.h
@@ -9,7 +9,7 @@
 #if (_WIN32_WCE > 300)
 #include <basetyps.h>
 #else
-#define MIDL_INTERFACE(x) struct 
+#define MIDL_INTERFACE(x) struct
 #endif
 #else
 #include <basetyps.h>
@@ -17,7 +17,7 @@

 #include <unknwn.h>

-#else 
+#else
 #include "MyWindows.h"
 #endif
  
--- a/CPP/Common/MyVector.cpp
+++ b/CPP/Common/MyVector.cpp
@@ -6,11 +6,12 @@

 #include "MyVector.h"

-CBaseRecordVector::~CBaseRecordVector() { Free(); }
+CBaseRecordVector::~CBaseRecordVector() { ClearAndFree(); }

-void CBaseRecordVector::Free()
-{ 
-  delete []((unsigned char *)_items); 
+void CBaseRecordVector::ClearAndFree()
+{
+  Clear();
+  delete []((unsigned char *)_items);
  _capacity = 0;
  _size = 0;
  _items = 0;
@@ -24,39 +25,47 @@ void CBaseRecordVector::ReserveOnePosition()
 {
  if (_size != _capacity)
    return;
-  int delta;
-  if (_capacity > 64)
-    delta = _capacity / 2;
-  else if (_capacity > 8)
+  int delta = 1;
+  if (_capacity >= 64)
+    delta = _capacity / 4;
+  else if (_capacity >= 8)
    delta = 8;
-  else
-    delta = 4;
  Reserve(_capacity + delta);
 }

 void CBaseRecordVector::Reserve(int newCapacity)
 {
-  if (newCapacity <= _capacity)
+  // if (newCapacity <= _capacity)
+  if (newCapacity == _capacity)
    return;
  if ((unsigned)newCapacity >= ((unsigned)1 << (sizeof(unsigned) * 8 - 1)))
    throw 1052353;
  size_t newSize = (size_t)(unsigned)newCapacity * _itemSize;
  if (newSize / _itemSize != (size_t)(unsigned)newCapacity)
    throw 1052354;
-  unsigned char *p = new unsigned char[newSize];
-  if (p == 0)
-    throw 1052355;
-  int numRecordsToMove = _capacity;
-  memmove(p, _items, _itemSize * numRecordsToMove);
+  unsigned char *p = NULL;
+  if (newSize > 0)
+  {
+    p = new unsigned char[newSize];
+    if (p == 0)
+      throw 1052355;
+    int numRecordsToMove = _size;
+    memcpy(p, _items, _itemSize * numRecordsToMove);
+  }
  delete [](unsigned char *)_items;
  _items = p;
  _capacity = newCapacity;
 }

+void CBaseRecordVector::ReserveDown()
+{
+  Reserve(_size);
+}
+
 void CBaseRecordVector::MoveItems(int destIndex, int srcIndex)
 {
-  memmove(((unsigned char *)_items) + destIndex * _itemSize, 
-    ((unsigned char  *)_items) + srcIndex * _itemSize, 
+  memmove(((unsigned char *)_items) + destIndex * _itemSize,
+    ((unsigned char  *)_items) + srcIndex * _itemSize,
    _itemSize * (_size - srcIndex));
 }

--- a/CPP/Common/MyVector.h
+++ b/CPP/Common/MyVector.h
@@ -17,15 +17,15 @@ protected:
  void ReserveOnePosition();
  void InsertOneItem(int index);
  void TestIndexAndCorrectNum(int index, int &num) const
-    { if (index + num > _size) num = _size - index; } 
+    { if (index + num > _size) num = _size - index; }
 public:
-  CBaseRecordVector(size_t itemSize):
-      _capacity(0), _size(0), _items(0), _itemSize(itemSize) {}
+  CBaseRecordVector(size_t itemSize): _capacity(0), _size(0), _items(0), _itemSize(itemSize) {}
  virtual ~CBaseRecordVector();
-  void Free();
+  void ClearAndFree();
  int Size() const { return _size; }
  bool IsEmpty() const { return (_size == 0); }
  void Reserve(int newCapacity);
+  void ReserveDown();
  virtual void Delete(int index, int num = 1);
  void Clear();
  void DeleteFrom(int index);
@@ -36,9 +36,8 @@ template <class T>
 class CRecordVector: public CBaseRecordVector
 {
 public:
-  CRecordVector():CBaseRecordVector(sizeof(T)){};
-  CRecordVector(const CRecordVector &v):
-    CBaseRecordVector(sizeof(T)) { *this = v;}
+  CRecordVector(): CBaseRecordVector(sizeof(T)){};
+  CRecordVector(const CRecordVector &v): CBaseRecordVector(sizeof(T)) { *this = v; }
  CRecordVector& operator=(const CRecordVector &v)
  {
    Clear();
@@ -68,9 +67,9 @@ public:
  const T& operator[](int index) const { return ((T *)_items)[index]; }
  T& operator[](int index) { return ((T *)_items)[index]; }
  const T& Front() const { return operator[](0); }
-  T& Front()   { return operator[](0); }
+  T& Front() { return operator[](0); }
  const T& Back() const { return operator[](_size - 1); }
-  T& Back()   { return operator[](_size - 1); }
+  T& Back() { return operator[](_size - 1); }

  void Swap(int i, int j)
  {
@@ -81,7 +80,7 @@ public:

  int FindInSorted(const T& item) const
  {
-    int left = 0, right = Size(); 
+    int left = 0, right = Size();
    while (left != right)
    {
      int mid = (left + right) / 2;
@@ -98,7 +97,7 @@ public:

  int AddToUniqueSorted(const T& item)
  {
-    int left = 0, right = Size(); 
+    int left = 0, right = Size();
    while (left != right)
    {
      int mid = (left + right) / 2;
@@ -115,7 +114,7 @@ public:
  }

  static void SortRefDown(T* p, int k, int size, int (*compare)(const T*, const T*, void *), void *param)
-  { 
+  {
    T temp = p[k];
    for (;;)
    {
@@ -126,10 +125,10 @@ public:
        s++;
      if (compare(&temp, p + s, param) >= 0)
        break;
-      p[k] = p[s]; 
+      p[k] = p[s];
      k = s;
-    } 
-    p[k] = temp; 
+    }
+    p[k] = temp;
  }

  void Sort(int (*compare)(const T*, const T*, void *), void *param)
@@ -165,21 +164,20 @@ template <class T>
 class CObjectVector: public CPointerVector
 {
 public:
-  CObjectVector(){};
-  ~CObjectVector() { Clear(); }
-  CObjectVector(const CObjectVector &objectVector)
-    { *this = objectVector; }
-  CObjectVector& operator=(const CObjectVector &objectVector)
+  CObjectVector() {};
+  ~CObjectVector() { Clear(); };
+  CObjectVector(const CObjectVector &v) { *this = v; }
+  CObjectVector& operator=(const CObjectVector &v)
  {
    Clear();
-    return (*this += objectVector);
+    return (*this += v);
  }
-  CObjectVector& operator+=(const CObjectVector &objectVector)
+  CObjectVector& operator+=(const CObjectVector &v)
  {
-    int size = objectVector.Size();
+    int size = v.Size();
    Reserve(Size() + size);
    for(int i = 0; i < size; i++)
-      Add(objectVector[i]);
+      Add(v[i]);
    return *this;
  }
  const T& operator[](int index) const { return *((T *)CPointerVector::operator[](index)); }
@@ -188,10 +186,8 @@ public:
  const T& Front() const { return operator[](0); }
  T& Back() { return operator[](_size - 1); }
  const T& Back() const { return operator[](_size - 1); }
-  int Add(const T& item)
-    { return CPointerVector::Add(new T(item)); }
-  void Insert(int index, const T& item)
-    { CPointerVector::Insert(index, new T(item)); }
+  int Add(const T& item) { return CPointerVector::Add(new T(item)); }
+  void Insert(int index, const T& item) { CPointerVector::Insert(index, new T(item)); }
  virtual void Delete(int index, int num = 1)
  {
    TestIndexAndCorrectNum(index, num);
@@ -204,11 +200,11 @@ public:
    for(int i = 0; i < Size(); i++)
      if (item == (*this)[i])
        return i;
-      return -1;
+    return -1;
  }
  int FindInSorted(const T& item) const
  {
-    int left = 0, right = Size(); 
+    int left = 0, right = Size();
    while (left != right)
    {
      int mid = (left + right) / 2;
@@ -224,7 +220,7 @@ public:
  }
  int AddToSorted(const T& item)
  {
-    int left = 0, right = Size(); 
+    int left = 0, right = Size();
    while (left != right)
    {
      int mid = (left + right) / 2;
@@ -243,7 +239,7 @@ public:
    return right;
  }

-  void Sort(int (*compare)(void *const *, void *const *, void *), void *param) 
+  void Sort(int (*compare)(void *const *, void *const *, void *), void *param)
    { CPointerVector::Sort(compare, param); }

  static int CompareObjectItems(void *const *a1, void *const *a2, void * /* param */)
@@ -251,4 +247,4 @@ public:
  void Sort() { CPointerVector::Sort(CompareObjectItems, 0); }
 };

-#endif 
+#endif
--- a/CPP/Common/MyWindows.cpp
+++ b/CPP/Common/MyWindows.cpp
@@ -12,7 +12,7 @@ static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
 static inline void FreeForBSTR(void *pv) { ::free(pv);}

 static UINT MyStringLen(const wchar_t *s)
-{ 
+{
  UINT i;
  for (i = 0; s[i] != '\0'; i++);
  return i;
@@ -81,7 +81,7 @@ HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src)
    return res;
  if (src->vt == VT_BSTR)
  {
-    dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal, 
+    dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
        SysStringByteLen(src->bstrVal));
    if (dest->bstrVal == 0)
      return E_OUTOFMEMORY;
--- a/CPP/Common/MyWindows.h
+++ b/CPP/Common/MyWindows.h
@@ -85,9 +85,9 @@ typedef LONG SCODE;
 #define E_INVALIDARG ((HRESULT)0x80070057L)

 #ifdef _MSC_VER
-#define STDMETHODCALLTYPE __stdcall 
+#define STDMETHODCALLTYPE __stdcall
 #else
-#define STDMETHODCALLTYPE 
+#define STDMETHODCALLTYPE
 #endif

 #define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f
@@ -97,7 +97,7 @@ typedef LONG SCODE;

 #define PURE = 0

-#define MIDL_INTERFACE(x) struct 
+#define MIDL_INTERFACE(x) struct

 #ifdef __cplusplus

@@ -163,7 +163,7 @@ typedef struct tagPROPVARIANT
  PROPVAR_PAD1 wReserved1;
  PROPVAR_PAD2 wReserved2;
  PROPVAR_PAD3 wReserved3;
-  union 
+  union
  {
    CHAR cVal;
    UCHAR bVal;
--- a/CPP/Common/MyXml.cpp
+++ b/CPP/Common/MyXml.cpp
@@ -0,0 +1,209 @@
+// MyXml.cpp
+
+#include "StdAfx.h"
+
+#include "MyXml.h"
+
+static bool IsValidChar(char c)
+{
+  return
+    c >= 'a' && c <= 'z' ||
+    c >= 'A' && c <= 'Z' ||
+    c >= '0' && c <= '9' ||
+    c == '-';
+}
+
+static bool IsSpaceChar(char c)
+{
+  return (c == ' ' || c == '\t' || c == 0x0D || c == 0x0A);
+}
+
+#define SKEEP_SPACES(s, pos) while (IsSpaceChar(s[pos])) pos++;
+
+static bool ReadProperty(const AString &s, int &pos, CXmlProp &prop)
+{
+  prop.Name.Empty();
+  prop.Value.Empty();
+  for (; pos < s.Length(); pos++)
+  {
+    char c = s[pos];
+    if (!IsValidChar(c))
+      break;
+    prop.Name += c;
+  }
+  
+  if (prop.Name.IsEmpty())
+    return false;
+
+  SKEEP_SPACES(s, pos);
+  if (s[pos++] != '=')
+    return false;
+
+  SKEEP_SPACES(s, pos);
+  if (s[pos++] != '\"')
+    return false;
+  
+  while (pos < s.Length())
+  {
+    char c = s[pos++];
+    if (c == '\"')
+      return true;
+    prop.Value += c;
+  }
+  return false;
+}
+
+int CXmlItem::FindProperty(const AString &propName) const
+{
+  for (int i = 0; i < Props.Size(); i++)
+    if (Props[i].Name == propName)
+      return i;
+  return -1;
+}
+
+AString CXmlItem::GetPropertyValue(const AString &propName) const
+{
+  int index = FindProperty(propName);
+  if (index >= 0)
+    return Props[index].Value;
+  return AString();
+}
+
+bool CXmlItem::IsTagged(const AString &tag) const
+{
+  return (IsTag && Name == tag);
+}
+
+int CXmlItem::FindSubTag(const AString &tag) const
+{
+  for (int i = 0; i < SubItems.Size(); i++)
+    if (SubItems[i].IsTagged(tag))
+      return i;
+  return -1;
+}
+
+AString CXmlItem::GetSubString() const
+{
+  if (SubItems.Size() == 1)
+  {
+    const CXmlItem &item = SubItems[0];
+    if (!item.IsTag)
+      return item.Name;
+  }
+  return AString();
+}
+
+AString CXmlItem::GetSubStringForTag(const AString &tag) const
+{
+  int index = FindSubTag(tag);
+  if (index >= 0)
+    return SubItems[index].GetSubString();
+  return AString();
+}
+
+bool CXmlItem::ParseItems(const AString &s, int &pos, int numAllowedLevels)
+{
+  if (numAllowedLevels == 0)
+    return false;
+  SubItems.Clear();
+  AString finishString = "</";
+  for (;;)
+  {
+    SKEEP_SPACES(s, pos);
+
+    if (s.Mid(pos, finishString.Length()) == finishString)
+      return true;
+      
+    CXmlItem item;
+    if (!item.ParseItem(s, pos, numAllowedLevels - 1))
+      return false;
+    SubItems.Add(item);
+  }
+}
+
+bool CXmlItem::ParseItem(const AString &s, int &pos, int numAllowedLevels)
+{
+  SKEEP_SPACES(s, pos);
+
+  int pos2 = s.Find('<', pos);
+  if (pos2 < 0)
+    return false;
+  if (pos2 != pos)
+  {
+    IsTag = false;
+    Name += s.Mid(pos, pos2 - pos);
+    pos = pos2;
+    return true;
+  }
+  IsTag = true;
+
+  pos++;
+  SKEEP_SPACES(s, pos);
+
+  for (; pos < s.Length(); pos++)
+  {
+    char c = s[pos];
+    if (!IsValidChar(c))
+      break;
+    Name += c;
+  }
+  if (Name.IsEmpty() || pos == s.Length())
+    return false;
+
+  int posTemp = pos;
+  for (;;)
+  {
+    SKEEP_SPACES(s, pos);
+    if (s[pos] == '/')
+    {
+      pos++;
+      // SKEEP_SPACES(s, pos);
+      return (s[pos++] == '>');
+    }
+    if (s[pos] == '>')
+    {
+      if (!ParseItems(s, ++pos, numAllowedLevels))
+        return false;
+      AString finishString = AString("</") + Name + AString(">");
+      if (s.Mid(pos, finishString.Length()) != finishString)
+        return false;
+      pos += finishString.Length();
+      return true;
+    }
+    if (posTemp == pos)
+      return false;
+
+    CXmlProp prop;
+    if (!ReadProperty(s, pos, prop))
+      return false;
+    Props.Add(prop);
+    posTemp = pos;
+  }
+}
+
+bool SkeepHeader(const AString &s, int &pos, const AString &startString, const AString &endString)
+{
+  SKEEP_SPACES(s, pos);
+  if (s.Mid(pos, startString.Length()) == startString)
+  {
+    pos = s.Find(endString, pos);
+    if (pos < 0)
+      return false;
+    pos += endString.Length();
+    SKEEP_SPACES(s, pos);
+  }
+  return true;
+}
+
+bool CXml::Parse(const AString &s)
+{
+  int pos = 0;
+  if (!SkeepHeader(s, pos, "<?xml", "?>"))
+    return false;
+  if (!SkeepHeader(s, pos, "<!DOCTYPE", ">"))
+    return false;
+  if (!Root.ParseItem(s, pos, 1000))
+    return false;
+  SKEEP_SPACES(s, pos);
+  return (pos == s.Length() && Root.IsTag);
+}
--- a/CPP/Common/MyXml.h
+++ b/CPP/Common/MyXml.h
@@ -0,0 +1,40 @@
+// MyXml.h
+
+#ifndef __MYXML_H
+#define __MYXML_H
+
+#include "MyString.h"
+
+struct CXmlProp
+{
+  AString Name;
+  AString Value;
+};
+
+class CXmlItem
+{
+  bool ParseItems(const AString &s, int &pos, int numAllowedLevels);
+
+public:
+  AString Name;
+  bool IsTag;
+  CObjectVector<CXmlProp> Props;
+  CObjectVector<CXmlItem> SubItems;
+
+  bool ParseItem(const AString &s, int &pos, int numAllowedLevels);
+  
+  bool IsTagged(const AString &tag) const;
+  int FindProperty(const AString &propName) const;
+  AString GetPropertyValue(const AString &propName) const;
+  AString GetSubString() const;
+  int FindSubTag(const AString &tag) const;
+  AString GetSubStringForTag(const AString &tag) const;
+};
+
+struct CXml
+{
+  CXmlItem Root;
+  bool Parse(const AString &s);
+};
+
+#endif
--- a/CPP/Common/NewHandler.cpp
+++ b/CPP/Common/NewHandler.cpp
@@ -11,9 +11,9 @@
 #ifndef DEBUG_MEMORY_LEAK

 #ifdef _WIN32
-void * 
+void *
 #ifdef _MSC_VER
-__cdecl 
+__cdecl
 #endif
 operator new(size_t size)
 {
@@ -24,9 +24,9 @@ operator new(size_t size)
  return p;
 }

-void 
+void
 #ifdef _MSC_VER
-__cdecl 
+__cdecl
 #endif
 operator delete(void *p) throw()
 {
--- a/CPP/Common/NewHandler.h
+++ b/CPP/Common/NewHandler.h
@@ -6,11 +6,11 @@
 class CNewException {};

 #ifdef _WIN32
-void 
+void
 #ifdef _MSC_VER
-__cdecl 
+__cdecl
 #endif
 operator delete(void *p) throw();
-#endif 
+#endif

-#endif 
+#endif
--- a/CPP/Common/StdAfx.h
+++ b/CPP/Common/StdAfx.h
@@ -6,4 +6,4 @@
 // #include "MyWindows.h"
 #include "NewHandler.h"

-#endif 
+#endif
--- a/CPP/Common/StdInStream.cpp
+++ b/CPP/Common/StdInStream.cpp
@@ -14,7 +14,7 @@ static const char kIllegalChar = '\0';
 static const char kNewLineChar = '\n';

 static const char *kEOFMessage = "Unexpected end of input stream";
-static const char *kReadErrorMessage  ="Error reading input stream"; 
+static const char *kReadErrorMessage  ="Error reading input stream";
 static const char *kIllegalCharMessage = "Illegal character in input stream";

 static LPCTSTR kFileOpenMode = TEXT("r");
--- a/CPP/Common/StdInStream.h
+++ b/CPP/Common/StdInStream.h
@@ -8,7 +8,7 @@
 #include "MyString.h"
 #include "Types.h"

-class CStdInStream 
+class CStdInStream
 {
  bool _streamIsOpen;
  FILE *_stream;
--- a/CPP/Common/StdOutStream.cpp
+++ b/CPP/Common/StdOutStream.cpp
@@ -51,7 +51,7 @@ CStdOutStream::~CStdOutStream ()

 CStdOutStream & CStdOutStream::operator<<(CStdOutStream & (*aFunction)(CStdOutStream  &))
 {
-  (*aFunction)(*this);    
+  (*aFunction)(*this);
  return *this;
 }

--- a/CPP/Common/StdOutStream.h
+++ b/CPP/Common/StdOutStream.h
@@ -7,7 +7,7 @@

 #include "Types.h"

-class CStdOutStream 
+class CStdOutStream
 {
  bool _streamIsOpen;
  FILE *_stream;
--- a/CPP/Common/StringConvert.cpp
+++ b/CPP/Common/StringConvert.cpp
@@ -14,8 +14,8 @@ UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
  UString resultString;
  if(!srcString.IsEmpty())
  {
-    int numChars = MultiByteToWideChar(codePage, 0, srcString, 
-      srcString.Length(), resultString.GetBuffer(srcString.Length()), 
+    int numChars = MultiByteToWideChar(codePage, 0, srcString,
+      srcString.Length(), resultString.GetBuffer(srcString.Length()),
      srcString.Length() + 1);
    #ifndef _WIN32_WCE
    if(numChars == 0)
@@ -34,8 +34,8 @@ AString UnicodeStringToMultiByte(const UString &s, UINT codePage, char defaultCh
  {
    int numRequiredBytes = s.Length() * 2;
    BOOL defUsed;
-    int numChars = WideCharToMultiByte(codePage, 0, s, s.Length(), 
-        dest.GetBuffer(numRequiredBytes), numRequiredBytes + 1, 
+    int numChars = WideCharToMultiByte(codePage, 0, s, s.Length(),
+        dest.GetBuffer(numRequiredBytes), numRequiredBytes + 1,
        &defaultChar, &defUsed);
    defaultCharWasUsed = (defUsed != FALSE);
    #ifndef _WIN32_WCE
--- a/CPP/Common/StringToInt.cpp
+++ b/CPP/Common/StringToInt.cpp
@@ -40,6 +40,28 @@ UInt64 ConvertOctStringToUInt64(const char *s, const char **end)
  }
 }

+UInt64 ConvertHexStringToUInt64(const char *s, const char **end)
+{
+  UInt64 result = 0;
+  for (;;)
+  {
+    char c = *s;
+    UInt32 v;
+    if (c >= '0' && c <= '9') v = (c - '0');
+    else if (c >= 'A' && c <= 'F') v = 10 + (c - 'A');
+    else if (c >= 'a' && c <= 'f') v = 10 + (c - 'a');
+    else
+    {
+      if (end != NULL)
+        *end = s;
+      return result;
+    }
+    result <<= 4;
+    result |= v;
+    s++;
+  }
+}
+

 UInt64 ConvertStringToUInt64(const wchar_t *s, const wchar_t **end)
 {
--- a/CPP/Common/StringToInt.h
+++ b/CPP/Common/StringToInt.h
@@ -8,6 +8,7 @@

 UInt64 ConvertStringToUInt64(const char *s, const char **end);
 UInt64 ConvertOctStringToUInt64(const char *s, const char **end);
+UInt64 ConvertHexStringToUInt64(const char *s, const char **end);
 UInt64 ConvertStringToUInt64(const wchar_t *s, const wchar_t **end);

 Int64 ConvertStringToInt64(const char *s, const char **end);
--- a/CPP/Common/UTFConvert.cpp
+++ b/CPP/Common/UTFConvert.cpp
@@ -5,87 +5,141 @@
 #include "UTFConvert.h"
 #include "Types.h"

-static Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+static const Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

-// These functions are for UTF8 <-> UTF16 conversion.
-
-bool ConvertUTF8ToUnicode(const AString &src, UString &dest)
+static Bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, size_t srcLen)
 {
-  dest.Empty();
-  for(int i = 0; i < src.Length();)
+  size_t destPos = 0, srcPos = 0;
+  for (;;)
  {
-    Byte c = (Byte)src[i++];
+    Byte c;
+    int numAdds;
+    if (srcPos == srcLen)
+    {
+      *destLen = destPos;
+      return True;
+    }
+    c = (Byte)src[srcPos++];
+
    if (c < 0x80)
    {
-      dest += (wchar_t)c;
+      if (dest)
+        dest[destPos] = (wchar_t)c;
+      destPos++;
      continue;
    }
-    if(c < 0xC0)
-      return false;
-    int numAdds;
+    if (c < 0xC0)
+      break;
    for (numAdds = 1; numAdds < 5; numAdds++)
      if (c < kUtf8Limits[numAdds])
        break;
    UInt32 value = (c - kUtf8Limits[numAdds - 1]);
+
    do
    {
-      if (i >= src.Length())
-        return false;
-      Byte c2 = (Byte)src[i++];
+      Byte c2;
+      if (srcPos == srcLen)
+        break;
+      c2 = (Byte)src[srcPos++];
      if (c2 < 0x80 || c2 >= 0xC0)
-        return false;
+        break;
      value <<= 6;
      value |= (c2 - 0x80);
-      numAdds--;
    }
-    while(numAdds > 0);
+    while (--numAdds != 0);
+    
    if (value < 0x10000)
-      dest += (wchar_t)(value);
+    {
+      if (dest)
+        dest[destPos] = (wchar_t)value;
+      destPos++;
+    }
    else
    {
      value -= 0x10000;
      if (value >= 0x100000)
-        return false;
-      dest += (wchar_t)(0xD800 + (value >> 10));
-      dest += (wchar_t)(0xDC00 + (value & 0x3FF));
+        break;
+      if (dest)
+      {
+        dest[destPos + 0] = (wchar_t)(0xD800 + (value >> 10));
+        dest[destPos + 1] = (wchar_t)(0xDC00 + (value & 0x3FF));
+      }
+      destPos += 2;
    }
  }
-  return true; 
+  *destLen = destPos;
+  return False;
+}
+
+static Bool Utf16_To_Utf8(char *dest, size_t *destLen, const wchar_t *src, size_t srcLen)
+{
+  size_t destPos = 0, srcPos = 0;
+  for (;;)
+  {
+    unsigned numAdds;
+    UInt32 value;
+    if (srcPos == srcLen)
+    {
+      *destLen = destPos;
+      return True;
+    }
+    value = src[srcPos++];
+    if (value < 0x80)
+    {
+      if (dest)
+        dest[destPos] = (char)value;
+      destPos++;
+      continue;
+    }
+    if (value >= 0xD800 && value < 0xE000)
+    {
+      UInt32 c2;
+      if (value >= 0xDC00 || srcPos == srcLen)
+        break;
+      c2 = src[srcPos++];
+      if (c2 < 0xDC00 || c2 >= 0xE000)
+        break;
+      value = ((value - 0xD800) << 10) | (c2 - 0xDC00);
+    }
+    for (numAdds = 1; numAdds < 5; numAdds++)
+      if (value < (((UInt32)1) << (numAdds * 5 + 6)))
+        break;
+    if (dest)
+      dest[destPos] = (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
+    destPos++;
+    do
+    {
+      numAdds--;
+      if (dest)
+        dest[destPos] = (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
+      destPos++;
+    }
+    while (numAdds != 0);
+  }
+  *destLen = destPos;
+  return False;
+}
+
+bool ConvertUTF8ToUnicode(const AString &src, UString &dest)
+{
+  dest.Empty();
+  size_t destLen = 0;
+  Utf8_To_Utf16(NULL, &destLen, src, src.Length());
+  wchar_t *p = dest.GetBuffer((int)destLen);
+  Bool res = Utf8_To_Utf16(p, &destLen, src, src.Length());
+  p[destLen] = 0;
+  dest.ReleaseBuffer();
+  return res ? true : false;
 }

 bool ConvertUnicodeToUTF8(const UString &src, AString &dest)
 {
  dest.Empty();
-  for(int i = 0; i < src.Length();)
-  {
-    UInt32 value = (UInt32)src[i++];
-    if (value < 0x80)
-    {
-      dest += (char)value;
-      continue;
-    }
-    if (value >= 0xD800 && value < 0xE000)
-    {
-      if (value >= 0xDC00)
-        return false;
-      if (i >= src.Length())
-        return false;
-      UInt32 c2 = (UInt32)src[i++];
-      if (c2 < 0xDC00 || c2 >= 0xE000)
-        return false;
-      value = ((value - 0xD800) << 10) | (c2 - 0xDC00);
-    }
-    int numAdds;
-    for (numAdds = 1; numAdds < 5; numAdds++)
-      if (value < (((UInt32)1) << (numAdds * 5 + 6)))
-        break;
-    dest += (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));
-    do
-    {
-      numAdds--;
-      dest += (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));
-    }
-    while(numAdds > 0);
-  }
-  return true;
+  size_t destLen = 0;
+  Utf16_To_Utf8(NULL, &destLen, src, src.Length());
+  char *p = dest.GetBuffer((int)destLen);
+  Bool res = Utf16_To_Utf8(p, &destLen, src, src.Length());
+  p[destLen] = 0;
+  dest.ReleaseBuffer();
+  return res ? true : false;
 }
--- a/CPP/Common/Wildcard.cpp
+++ b/CPP/Common/Wildcard.cpp
@@ -4,7 +4,7 @@

 #include "Wildcard.h"

-bool g_CaseSensitive = 
+bool g_CaseSensitive =
  #ifdef _WIN32
    false;
  #else
@@ -31,7 +31,7 @@ static inline bool IsCharDirLimiter(wchar_t c)
 {
  return (
    #ifdef _WIN32
-    c == kDirDelimiter1 || 
+    c == kDirDelimiter1 ||
    #endif
    c == kDirDelimiter2);
 }
@@ -54,20 +54,20 @@ static bool EnhancedMaskTest(const wchar_t *mask, const wchar_t *name)
  {
    wchar_t m = *mask;
    wchar_t c = *name;
-    if (m == 0) 
+    if (m == 0)
      return (c == 0);
    if (m == kAnyCharsChar)
    {
      if (EnhancedMaskTest(mask + 1, name))
        return true;
-      if (c == 0) 
+      if (c == 0)
        return false;
    }
    else
    {
      if (m == kAnyCharChar)
      {
-        if (c == 0) 
+        if (c == 0)
          return false;
      }
      else if (m != c)
@@ -155,7 +155,7 @@ N = TestNameParts.Size();

                           File                          Dir
 ForFile     req   M<=N  [N-M, N)                          -
-         nonreq   M=N   [0, M)                            -  
+         nonreq   M=N   [0, M)                            -
 
 ForDir      req   M<N   [0, M) ... [N-M-1, N-1)  same as ForBoth-File
         nonreq         [0, M)                   same as ForBoth-File
@@ -301,7 +301,7 @@ bool CCensorNode::CheckPath(UStringVector &pathParts, bool isFile, bool &include

 bool CCensorNode::CheckPath(const UString &path, bool isFile, bool &include) const
 {
-  UStringVector pathParts; 
+  UStringVector pathParts;
  SplitPathToParts(path, pathParts);
  return CheckPath(pathParts, isFile, include);
 }
@@ -327,7 +327,7 @@ bool CCensorNode::CheckPathToRoot(bool include, UStringVector &pathParts, bool i
 /*
 bool CCensorNode::CheckPathToRoot(bool include, const UString &path, bool isFile) const
 {
-  UStringVector pathParts; 
+  UStringVector pathParts;
  SplitPathToParts(path, pathParts);
  return CheckPathToRoot(include, pathParts, isFile);
 }