23.0123.01

55 files changed, 1456 insertions, 658 deletions

diff --git a/CPP/Common/AutoPtr.h b/CPP/Common/AutoPtr.h
index 006d315..0be8a7a 100644
--- a/CPP/Common/AutoPtr.h
+++ b/CPP/Common/AutoPtr.h
@@ -1,13 +1,13 @@
 // Common/AutoPtr.h
 
-#ifndef __COMMON_AUTOPTR_H
-#define __COMMON_AUTOPTR_H
+#ifndef ZIP7_INC_COMMON_AUTOPTR_H
+#define ZIP7_INC_COMMON_AUTOPTR_H
 
 template<class T> class CMyAutoPtr
 {
   T *_p;
 public:
-  CMyAutoPtr(T *p = 0) : _p(p) {}
+  CMyAutoPtr(T *p = NULL) : _p(p) {}
   CMyAutoPtr(CMyAutoPtr<T>& p): _p(p.release()) {}
   CMyAutoPtr<T>& operator=(CMyAutoPtr<T>& p)
   {
@@ -21,10 +21,10 @@ public:
   T* release()
   {
     T *tmp = _p;
-    _p = 0;
+    _p = NULL;
     return tmp;
   }
-  void reset(T* p = 0)
+  void reset(T* p = NULL)
   {
     if (p != _p)
       delete _p;
diff --git a/CPP/Common/C_FileIO.h b/CPP/Common/C_FileIO.h
index 6818558..12d9439 100644
--- a/CPP/Common/C_FileIO.h
+++ b/CPP/Common/C_FileIO.h
@@ -1,6 +1,6 @@
 // Common/C_FileIO.h
 
-#ifndef __COMMON_C_FILEIO_H
-#define __COMMON_C_FILEIO_H
+#ifndef ZIP7_INC_COMMON_C_FILEIO_H
+#define ZIP7_INC_COMMON_C_FILEIO_H
 
 #endif
diff --git a/CPP/Common/CksumReg.cpp b/CPP/Common/CksumReg.cpp
index 29d9f82..8c9c449 100644
--- a/CPP/Common/CksumReg.cpp
+++ b/CPP/Common/CksumReg.cpp
@@ -7,35 +7,30 @@
 #include "../Common/MyCom.h"
 
 #include "../7zip/Common/RegisterCodec.h"
-
 #include "../7zip/Compress/BZip2Crc.h"
 
-class CCksumHasher:
-  public IHasher,
-  public CMyUnknownImp
-{
+Z7_CLASS_IMP_COM_1(
+  CCksumHasher
+  , IHasher
+)
   CBZip2Crc _crc;
   UInt64 _size;
-  Byte mtDummy[1 << 7];
-  
 public:
+  // Byte _mtDummy[1 << 7];
   CCksumHasher()
   {
     _crc.Init(0);
     _size = 0;
   }
-
-  MY_UNKNOWN_IMP1(IHasher)
-  INTERFACE_IHasher(;)
 };
 
-STDMETHODIMP_(void) CCksumHasher::Init() throw()
+Z7_COM7F_IMF2(void, CCksumHasher::Init())
 {
   _crc.Init(0);
   _size = 0;
 }
 
-STDMETHODIMP_(void) CCksumHasher::Update(const void *data, UInt32 size) throw()
+Z7_COM7F_IMF2(void, CCksumHasher::Update(const void *data, UInt32 size))
 {
   _size += size;
   CBZip2Crc crc = _crc;
@@ -44,7 +39,7 @@ STDMETHODIMP_(void) CCksumHasher::Update(const void *data, UInt32 size) throw()
   _crc = crc;
 }
 
-STDMETHODIMP_(void) CCksumHasher::Final(Byte *digest) throw()
+Z7_COM7F_IMF2(void, CCksumHasher::Final(Byte *digest))
 {
   UInt64 size = _size;
   CBZip2Crc crc = _crc;
@@ -54,7 +49,7 @@ STDMETHODIMP_(void) CCksumHasher::Final(Byte *digest) throw()
     size >>= 8;
   }
   const UInt32 val = crc.GetDigest();
-  SetUi32(digest, val);
+  SetUi32(digest, val)
 }
 
 REGISTER_HASHER(CCksumHasher, 0x203, "CKSUM", 4)
diff --git a/CPP/Common/ComTry.h b/CPP/Common/ComTry.h
index 297c407..84746a7 100644
--- a/CPP/Common/ComTry.h
+++ b/CPP/Common/ComTry.h
@@ -1,7 +1,7 @@
 // ComTry.h
 
-#ifndef __COM_TRY_H
-#define __COM_TRY_H
+#ifndef ZIP7_INC_COM_TRY_H
+#define ZIP7_INC_COM_TRY_H
 
 #include "MyWindows.h"
 // #include "Exception.h"
diff --git a/CPP/Common/CommandLineParser.h b/CPP/Common/CommandLineParser.h
index fbd4fa5..fc6f028 100644
--- a/CPP/Common/CommandLineParser.h
+++ b/CPP/Common/CommandLineParser.h
@@ -1,7 +1,7 @@
 // Common/CommandLineParser.h
 
-#ifndef __COMMON_COMMAND_LINE_PARSER_H
-#define __COMMON_COMMAND_LINE_PARSER_H
+#ifndef ZIP7_INC_COMMON_COMMAND_LINE_PARSER_H
+#define ZIP7_INC_COMMON_COMMAND_LINE_PARSER_H
 
 #include "MyString.h"
 
diff --git a/CPP/Common/Common.h b/CPP/Common/Common.h
index 72db7a8..0c77ab4 100644
--- a/CPP/Common/Common.h
+++ b/CPP/Common/Common.h
@@ -1,7 +1,13 @@
 // Common.h
 
-#ifndef __COMMON_COMMON_H
-#define __COMMON_COMMON_H
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#ifndef ZIP7_INC_COMMON_H
+#define ZIP7_INC_COMMON_H
+
+#include "../../C/Compiler.h"
 
 /*
 This file is included to all cpp files in 7-Zip.
@@ -16,42 +22,292 @@ If you don't need some things that are used in 7-Zip,
 you can change this h file or h files included in this file.
 */
 
-// compiler pragmas to disable some warnings
-#include "../../C/Compiler.h"
+#ifdef _MSC_VER
+  #pragma warning(disable : 4710) // function not inlined
+  // 'CUncopyable::CUncopyable':
+  #pragma warning(disable : 4514) // unreferenced inline function has been removed
+  #if _MSC_VER < 1300
+    #pragma warning(disable : 4702) // unreachable code
+    #pragma warning(disable : 4714) // function marked as __forceinline not inlined
+    #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
+  #endif
+  #if _MSC_VER < 1400
+    #pragma warning(disable : 4511) // copy constructor could not be generated    // #pragma warning(disable : 4512) // assignment operator could not be generated
+    #pragma warning(disable : 4512) // assignment operator could not be generated
+  #endif
+  #if _MSC_VER > 1400 && _MSC_VER <= 1900
+    // #pragma warning(disable : 4996)
+       // strcat: This function or variable may be unsafe
+       // GetVersion was declared deprecated
+  #endif
 
-// it's <windows.h> or code that defines windows things, if it's not _WIN32
-#include "MyWindows.h"
+#if _MSC_VER > 1200
+// -Wall warnings
 
-// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
-#include "NewHandler.h"
+#if _MSC_VER <= 1600
+#pragma warning(disable : 4917) // 'OLE_HANDLE' : a GUID can only be associated with a class, interface or namespace
+#endif
 
+// #pragma warning(disable : 4061) // enumerator '' in switch of enum '' is not explicitly handled by a case label
+// #pragma warning(disable : 4266) // no override available for virtual member function from base ''; function is hidden
+#pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+#pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+#if _MSC_VER >= 1600 && _MSC_VER < 1920
+#pragma warning(disable : 4571) // Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
+#endif
+#if _MSC_VER >= 1600
+#pragma warning(disable : 4365) // 'initializing' : conversion from 'int' to 'unsigned int', signed / unsigned mismatch
+#endif
+#if _MSC_VER < 1800
+// we disable the warning, if we don't use 'final' in class
+#pragma warning(disable : 4265) // class has virtual functions, but destructor is not virtual
+#endif
+
+#if _MSC_VER >= 1900
+#pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+#pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+#endif
+#if _MSC_VER >= 1912
+#pragma warning(disable : 5039) // pointer or reference to potentially throwing function passed to 'extern "C"' function under - EHc.Undefined behavior may occur if this function throws an exception.
+#endif
+#if _MSC_VER >= 1925
+// #pragma warning(disable : 5204) // 'ISequentialInStream' : class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
+#endif
+#if _MSC_VER >= 1934
+// #pragma warning(disable : 5264) // const variable is not used
+#endif
 
+#endif // _MSC_VER > 1200
+#endif // _MSC_VER
 
-#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+
+#if defined(_MSC_VER) // && !defined(__clang__)
+#define Z7_DECLSPEC_NOTHROW   __declspec(nothrow)
+#elif defined(__clang__) || defined(__GNUC__)
+#define Z7_DECLSPEC_NOTHROW   __attribute__((nothrow))
+#else
+#define Z7_DECLSPEC_NOTHROW
+#endif
+
+/*
+#if defined (_MSC_VER) && _MSC_VER >= 1900 \
+    || defined(__clang__) && __clang_major__ >= 6 \
+    || defined(__GNUC__) && __GNUC__ >= 6
+  #define Z7_noexcept noexcept
+#else
+  #define Z7_noexcept throw()
+#endif
+*/
+
+
+#if defined(__clang__)
+
+// noexcept, final, = delete
+#pragma GCC diagnostic ignored "-Wc++98-compat"
+#if __clang_major__ >= 4
+// throw() dynamic exception specifications are deprecated
+#pragma GCC diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wglobal-constructors"
+#pragma GCC diagnostic ignored "-Wexit-time-destructors"
+
+// #pragma GCC diagnostic ignored "-Wunused-private-field"
+// #pragma GCC diagnostic ignored "-Wnonportable-system-include-path"
+// #pragma GCC diagnostic ignored "-Wsuggest-override"
+// #pragma GCC diagnostic ignored "-Wsign-conversion"
+// #pragma GCC diagnostic ignored "-Winconsistent-missing-override"
+// #pragma GCC diagnostic ignored "-Wsuggest-destructor-override"
+// #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-with-user-provided-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-dtor"
+// #ifndef _WIN32
+// #pragma GCC diagnostic ignored "-Wweak-vtables"
+// #endif
+/*
+#if   defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400) \
+   || defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30000)
+// enumeration values not explicitly handled in switch
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+*/
+#endif // __clang__
+
+
+#ifdef __GNUC__
+// #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
 
 
 /* There is BUG in MSVC 6.0 compiler for operator new[]:
    It doesn't check overflow, when it calculates size in bytes for allocated array.
-   So we can use MY_ARRAY_NEW macro instead of new[] operator. */
+   So we can use Z7_ARRAY_NEW macro instead of new[] operator. */
 
 #if defined(_MSC_VER) && (_MSC_VER == 1200) && !defined(_WIN64)
-  #define MY_ARRAY_NEW(p, T, size) p = new T[((size) > (unsigned)0xFFFFFFFF / sizeof(T)) ? (unsigned)0xFFFFFFFF / sizeof(T) : (size)];
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[((size) > (unsigned)0xFFFFFFFF / sizeof(T)) ? (unsigned)0xFFFFFFFF / sizeof(T) : (size)];
 #else
-  #define MY_ARRAY_NEW(p, T, size) p = new T[size];
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[size];
 #endif
 
 #if (defined(__GNUC__) && (__GNUC__ >= 8))
-  #define MY_ATTR_NORETURN __attribute__((noreturn))
+  #define Z7_ATTR_NORETURN  __attribute__((noreturn))
 #elif (defined(__clang__) && (__clang_major__ >= 3))
   #if __has_feature(cxx_attributes)
-    #define MY_ATTR_NORETURN [[noreturn]]
+    #define Z7_ATTR_NORETURN  [[noreturn]]
   #else
-    #define MY_ATTR_NORETURN __attribute__ ((noreturn))
+    #define Z7_ATTR_NORETURN  __attribute__((noreturn))
   #endif
 #elif (defined(_MSC_VER) && (_MSC_VER >= 1900))
-  #define MY_ATTR_NORETURN [[noreturn]]
+  #define Z7_ATTR_NORETURN  [[noreturn]]
+#else
+  #define Z7_ATTR_NORETURN
+#endif
+
+
+// final in "GCC 4.7.0"
+// In C++98 and C++03 code the alternative spelling __final can be used instead (this is a GCC extension.)
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || defined(_MSC_VER) && _MSC_VER >= 1800 \
+    || defined(__clang__) && __clang_major__ >= 4 \
+    /* || defined(__GNUC__) && __GNUC__ >= 9 */
+  #define Z7_final  final
+  #if defined(__clang__) && __cplusplus < 201103L
+    #pragma GCC diagnostic ignored "-Wc++11-extensions"
+  #endif
+#elif defined (__cplusplus) && __cplusplus >= 199711L \
+    && defined(__GNUC__) && __GNUC__ >= 4 && !defined(__clang__)
+  #define Z7_final __final
 #else
-  #define MY_ATTR_NORETURN
+  #define Z7_final
+  #if defined(__clang__) && __clang_major__ >= 4 \
+     || defined(__GNUC__) && __GNUC__ >= 4
+    #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+    #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+  #endif
 #endif
 
+#define Z7_class_final(c)  class c Z7_final
+
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+  #define Z7_CPP_IS_SUPPORTED_default
+  #define Z7_eq_delete  = delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c) c(const c& k) = default;
+#else
+  #define Z7_eq_delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c)
 #endif
+
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L) \
+    || defined(_MSC_VER) && (_MSC_VER >= 1400) /* && (_MSC_VER != 1600) */ \
+    || defined(__clang__) && __clang_major__ >= 4
+  #if defined(_MSC_VER) && (_MSC_VER == 1600) /* && (_MSC_VER != 1600) */
+    #pragma warning(disable : 4481) // nonstandard extension used: override specifier 'override'
+    #define Z7_DESTRUCTOR_override
+  #else
+    #define Z7_DESTRUCTOR_override  override
+  #endif
+  #define Z7_override  override
+#else
+  #define Z7_override
+  #define Z7_DESTRUCTOR_override
+#endif
+
+
+
+#define Z7_CLASS_NO_COPY(cls) \
+  private: \
+  cls(const cls &) Z7_eq_delete; \
+  cls &operator=(const cls &) Z7_eq_delete;
+
+class CUncopyable
+{
+protected:
+  CUncopyable() {} // allow constructor
+  // ~CUncopyable() {}
+  Z7_CLASS_NO_COPY(CUncopyable)
+};
+
+#define MY_UNCOPYABLE  :private CUncopyable
+// #define MY_UNCOPYABLE
+
+
+typedef void (*Z7_void_Function)(void);
+
+#if defined(__clang__) || defined(__GNUC__)
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<Z7_void_Function>(e))
+#else
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<void*>(e))
+// #define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(e)
+#endif
+
+#define Z7_GET_PROC_ADDRESS(func_type, hmodule, func_name)  \
+    Z7_CAST_FUNC(func_type, GetProcAddress(hmodule, func_name))
+
+// || defined(__clang__)
+// || defined(__GNUC__)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define Z7_DECLSPEC_NOVTABLE __declspec(novtable)
+#else
+#define Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifdef __clang__
+#define Z7_PURE_INTERFACES_BEGIN \
+_Pragma("GCC diagnostic push") \
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+_Pragma("GCC diagnostic ignored \"-Wweak-vtables\"")
+#define Z7_PURE_INTERFACES_END \
+_Pragma("GCC diagnostic pop")
+#else
+#define Z7_PURE_INTERFACES_BEGIN
+#define Z7_PURE_INTERFACES_END
+#endif
+
+// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
+#include "NewHandler.h"
+
+/*
+// #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a)  Z7_ARRAY_SIZE(a)
+#endif
+*/
+
+#endif // ZIP7_INC_COMMON_H
+
+
+
+// #define Z7_REDEFINE_NULL
+
+#if defined(Z7_REDEFINE_NULL) /* && (!defined(__clang__) || defined(_MSC_VER)) */
+
+// NULL is defined in <stddef.h>
+#include <stddef.h>
+#undef NULL
+
+#ifdef __cplusplus
+  #if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #define NULL  nullptr
+  #else
+    #define NULL  0
+  #endif
+#else
+  #define NULL  ((void *)0)
+#endif
+
+#else // Z7_REDEFINE_NULL
+
+#if defined(__clang__) && __clang_major__ >= 5
+#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#endif // Z7_REDEFINE_NULL
+
+// for precompiler:
+#include "MyWindows.h"
diff --git a/CPP/Common/CrcReg.cpp b/CPP/Common/CrcReg.cpp
index fdbba77..6cda892 100644
--- a/CPP/Common/CrcReg.cpp
+++ b/CPP/Common/CrcReg.cpp
@@ -11,42 +11,39 @@
 
 EXTERN_C_BEGIN
 
-typedef UInt32 (MY_FAST_CALL *CRC_FUNC)(UInt32 v, const void *data, size_t size, const UInt32 *table);
-
-UInt32 MY_FAST_CALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
+// UInt32 Z7_FASTCALL CrcUpdateT1(UInt32 v, const void *data, size_t size, const UInt32 *table);
 
 extern CRC_FUNC g_CrcUpdate;
-extern CRC_FUNC g_CrcUpdateT4;
+// extern CRC_FUNC g_CrcUpdateT4;
 extern CRC_FUNC g_CrcUpdateT8;
 extern CRC_FUNC g_CrcUpdateT0_32;
 extern CRC_FUNC g_CrcUpdateT0_64;
 
 EXTERN_C_END
 
-class CCrcHasher:
-  public IHasher,
-  public ICompressSetCoderProperties,
-  public CMyUnknownImp
-{
+Z7_CLASS_IMP_COM_2(
+  CCrcHasher
+  , IHasher
+  , ICompressSetCoderProperties
+)
   UInt32 _crc;
   CRC_FUNC _updateFunc;
-  Byte mtDummy[1 << 7];
-  
+
+  Z7_CLASS_NO_COPY(CCrcHasher)
+
   bool SetFunctions(UInt32 tSize);
 public:
-  CCrcHasher(): _crc(CRC_INIT_VAL) { SetFunctions(0); }
+  Byte _mtDummy[1 << 7];  // it's public to eliminate clang warning: unused private field
 
-  MY_UNKNOWN_IMP2(IHasher, ICompressSetCoderProperties)
-  INTERFACE_IHasher(;)
-  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
+  CCrcHasher(): _crc(CRC_INIT_VAL) { SetFunctions(0); }
 };
 
 bool CCrcHasher::SetFunctions(UInt32 tSize)
 {
   CRC_FUNC f = NULL;
        if (tSize ==  0) f = g_CrcUpdate;
-  else if (tSize ==  1) f = CrcUpdateT1;
-  else if (tSize ==  4) f = g_CrcUpdateT4;
+  // else if (tSize ==  1) f = CrcUpdateT1;
+  // else if (tSize ==  4) f = g_CrcUpdateT4;
   else if (tSize ==  8) f = g_CrcUpdateT8;
   else if (tSize == 32) f = g_CrcUpdateT0_32;
   else if (tSize == 64) f = g_CrcUpdateT0_64;
@@ -60,13 +57,13 @@ bool CCrcHasher::SetFunctions(UInt32 tSize)
   return true;
 }
 
-STDMETHODIMP CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
+Z7_COM7F_IMF(CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
 {
   for (UInt32 i = 0; i < numProps; i++)
   {
-    const PROPVARIANT &prop = coderProps[i];
     if (propIDs[i] == NCoderPropID::kDefaultProp)
     {
+      const PROPVARIANT &prop = coderProps[i];
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
       if (!SetFunctions(prop.ulVal))
@@ -76,20 +73,20 @@ STDMETHODIMP CCrcHasher::SetCoderProperties(const PROPID *propIDs, const PROPVAR
   return S_OK;
 }
 
-STDMETHODIMP_(void) CCrcHasher::Init() throw()
+Z7_COM7F_IMF2(void, CCrcHasher::Init())
 {
   _crc = CRC_INIT_VAL;
 }
 
-STDMETHODIMP_(void) CCrcHasher::Update(const void *data, UInt32 size) throw()
+Z7_COM7F_IMF2(void, CCrcHasher::Update(const void *data, UInt32 size))
 {
   _crc = _updateFunc(_crc, data, size, g_CrcTable);
 }
 
-STDMETHODIMP_(void) CCrcHasher::Final(Byte *digest) throw()
+Z7_COM7F_IMF2(void, CCrcHasher::Final(Byte *digest))
 {
-  UInt32 val = CRC_GET_DIGEST(_crc);
-  SetUi32(digest, val);
+  const UInt32 val = CRC_GET_DIGEST(_crc);
+  SetUi32(digest, val)
 }
 
 REGISTER_HASHER(CCrcHasher, 0x1, "CRC32", 4)
diff --git a/CPP/Common/Defs.h b/CPP/Common/Defs.h
index 9adb88c..e302f35 100644
--- a/CPP/Common/Defs.h
+++ b/CPP/Common/Defs.h
@@ -1,7 +1,7 @@
 // Common/Defs.h
 
-#ifndef __COMMON_DEFS_H
-#define __COMMON_DEFS_H
+#ifndef ZIP7_INC_COMMON_DEFS_H
+#define ZIP7_INC_COMMON_DEFS_H
 
 template <class T> inline T MyMin(T a, T b) { return a < b ? a : b; }
 template <class T> inline T MyMax(T a, T b) { return a > b ? a : b; }
@@ -10,7 +10,7 @@ template <class T> inline int MyCompare(T a, T b)
   { return a == b ? 0 : (a < b ? -1 : 1); }
 
 inline int BoolToInt(bool v) { return (v ? 1 : 0); }
-inline unsigned BoolToUInt(bool v) { return (v ? (unsigned)1 : (unsigned)0); }
+inline unsigned BoolToUInt(bool v) { return (v ? 1u : 0u); }
 inline bool IntToBool(int v) { return (v != 0); }
 
 #endif
diff --git a/CPP/Common/DynLimBuf.cpp b/CPP/Common/DynLimBuf.cpp
index 7914104..1d92af3 100644
--- a/CPP/Common/DynLimBuf.cpp
+++ b/CPP/Common/DynLimBuf.cpp
@@ -7,7 +7,7 @@
 
 CDynLimBuf::CDynLimBuf(size_t limit) throw()
 {
-  _chars = 0;
+  _chars = NULL;
   _pos = 0;
   _size = 0;
   _sizeLimit = limit;
diff --git a/CPP/Common/DynLimBuf.h b/CPP/Common/DynLimBuf.h
index e80a7e7..af22f07 100644
--- a/CPP/Common/DynLimBuf.h
+++ b/CPP/Common/DynLimBuf.h
@@ -1,7 +1,7 @@
 // Common/DynLimBuf.h
 
-#ifndef __COMMON_DYN_LIM_BUF_H
-#define __COMMON_DYN_LIM_BUF_H
+#ifndef ZIP7_INC_COMMON_DYN_LIM_BUF_H
+#define ZIP7_INC_COMMON_DYN_LIM_BUF_H
 
 #include <string.h>
 
diff --git a/CPP/Common/DynamicBuffer.h b/CPP/Common/DynamicBuffer.h
index f6f6b15..714be4a 100644
--- a/CPP/Common/DynamicBuffer.h
+++ b/CPP/Common/DynamicBuffer.h
@@ -1,7 +1,11 @@
 // Common/DynamicBuffer.h
 
-#ifndef __COMMON_DYNAMIC_BUFFER_H
-#define __COMMON_DYNAMIC_BUFFER_H
+#ifndef ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+#define ZIP7_INC_COMMON_DYNAMIC_BUFFER_H
+
+#include <string.h>
+
+#include "Common.h"
 
 template <class T> class CDynamicBuffer
 {
@@ -34,7 +38,7 @@ template <class T> class CDynamicBuffer
   }
 
 public:
-  CDynamicBuffer(): _items(0), _size(0), _pos(0) {}
+  CDynamicBuffer(): _items(NULL), _size(0), _pos(0) {}
   // operator T *() { return _items; }
   operator const T *() const { return _items; }
   ~CDynamicBuffer() { delete []_items; }
diff --git a/CPP/Common/IntToString.cpp b/CPP/Common/IntToString.cpp
index c87643c..21b0680 100644
--- a/CPP/Common/IntToString.cpp
+++ b/CPP/Common/IntToString.cpp
@@ -16,7 +16,7 @@
 
 char * ConvertUInt32ToString(UInt32 val, char *s) throw()
 {
-  CONVERT_INT_TO_STR(char, 16);
+  CONVERT_INT_TO_STR(char, 16)
 }
 
 char * ConvertUInt64ToString(UInt64 val, char *s) throw()
@@ -25,7 +25,7 @@ char * ConvertUInt64ToString(UInt64 val, char *s) throw()
   {
     return ConvertUInt32ToString((UInt32)val, s);
   }
-  CONVERT_INT_TO_STR(char, 24);
+  CONVERT_INT_TO_STR(char, 24)
 }
 
 void ConvertUInt64ToOct(UInt64 val, char *s) throw()
@@ -102,7 +102,7 @@ void ConvertUInt32ToHex8Digits(UInt32 val, char *s) throw()
   {
     unsigned t = val & 0xF;
     val >>= 4;
-    s[i] = GET_HEX_CHAR(t);;
+    s[i] = GET_HEX_CHAR(t);
   }
 }
 
@@ -121,7 +121,7 @@ void ConvertUInt32ToHex8Digits(UInt32 val, wchar_t *s)
 
 wchar_t * ConvertUInt32ToString(UInt32 val, wchar_t *s) throw()
 {
-  CONVERT_INT_TO_STR(wchar_t, 16);
+  CONVERT_INT_TO_STR(wchar_t, 16)
 }
 
 wchar_t * ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
@@ -130,7 +130,7 @@ wchar_t * ConvertUInt64ToString(UInt64 val, wchar_t *s) throw()
   {
     return ConvertUInt32ToString((UInt32)val, s);
   }
-  CONVERT_INT_TO_STR(wchar_t, 24);
+  CONVERT_INT_TO_STR(wchar_t, 24)
 }
 
 void ConvertInt64ToString(Int64 val, char *s) throw()
diff --git a/CPP/Common/IntToString.h b/CPP/Common/IntToString.h
index d0a96ef..f4fc662 100644
--- a/CPP/Common/IntToString.h
+++ b/CPP/Common/IntToString.h
@@ -1,7 +1,7 @@
 // Common/IntToString.h
 
-#ifndef __COMMON_INT_TO_STRING_H
-#define __COMMON_INT_TO_STRING_H
+#ifndef ZIP7_INC_COMMON_INT_TO_STRING_H
+#define ZIP7_INC_COMMON_INT_TO_STRING_H
 
 #include "MyTypes.h"
 
diff --git a/CPP/Common/Lang.cpp b/CPP/Common/Lang.cpp
index 35d3752..b0b4342 100644
--- a/CPP/Common/Lang.cpp
+++ b/CPP/Common/Lang.cpp
@@ -12,85 +12,95 @@ void CLang::Clear() throw()
 {
   _ids.Clear();
   _offsets.Clear();
+  Comments.Clear();
   delete []_text;
-  _text = 0;
+  _text = NULL;
 }
 
-static const char * const kLangSignature = ";!@Lang2@!UTF-8!";
+static const char * const kLangSignature = ";!@Lang2@!UTF-8!\n";
 
 bool CLang::OpenFromString(const AString &s2)
 {
-  UString s;
-  if (!ConvertUTF8ToUnicode(s2, s))
+  UString su;
+  if (!ConvertUTF8ToUnicode(s2, su))
     return false;
-  unsigned i = 0;
-  if (s.IsEmpty())
+  if (su.IsEmpty())
     return false;
-  if (s[0] == 0xFEFF)
-    i++;
-
-  for (const char *p = kLangSignature;; i++)
+  const wchar_t *s = su;
+  const wchar_t *sLim = s + su.Len();
+  if (*s == 0xFEFF)
+    s++;
+  for (const char *p = kLangSignature;; s++)
   {
-    Byte c = (Byte)(*p++);
+    const Byte c = (Byte)(*p++);
     if (c == 0)
       break;
-    if (s[i] != c)
+    if (*s != c)
       return false;
   }
 
-  _text = new wchar_t[s.Len() - i + 1];
-  wchar_t *text = _text;
+  wchar_t *text = new wchar_t[(size_t)(sLim - s) + 1];
+  _text = text;
 
-  Int32 id = -100;
-  UInt32 pos = 0;
+  UString comment;
+  Int32 id = -1024;
+  unsigned pos = 0;
 
-  while (i < s.Len())
+  while (s != sLim)
   {
-    unsigned start = pos;
+    const unsigned start = pos;
     do
     {
-      wchar_t c = s[i++];
+      wchar_t c = *s++;
       if (c == '\n')
         break;
       if (c == '\\')
       {
-        if (i == s.Len())
+        if (s == sLim)
           return false;
-        c = s[i++];
+        c = *s++;
         switch (c)
         {
           case '\n': return false;
           case 'n': c = '\n'; break;
           case 't': c = '\t'; break;
-          case '\\': c = '\\'; break;
+          case '\\': /* c = '\\'; */ break;
           default: text[pos++] = L'\\'; break;
         }
       }
       text[pos++] = c;
     }
-    while (i < s.Len());
+    while (s != sLim);
 
     {
       unsigned j = start;
       for (; j < pos; j++)
-        if (text[j] != ' ')
+        if (text[j] != ' ' && text[j] != '\t')
           break;
       if (j == pos)
       {
         id++;
+        pos = start;
         continue;
       }
     }
+
+    // start != pos
+    text[pos++] = 0;
+
     if (text[start] == ';')
     {
-      pos = start;
+      comment = text + start;
+      comment.TrimRight();
+      if (comment.Len() != 1)
+        Comments.Add(comment);
       id++;
+      pos = start;
       continue;
     }
-    
-    text[pos++] = 0;
+
     const wchar_t *end;
-    UInt32 id32 = ConvertStringToUInt32(text + start, &end);
+    const UInt32 id32 = ConvertStringToUInt32(text + start, &end);
     if (*end == 0)
     {
       if (id32 > ((UInt32)1 << 30) || (Int32)id32 < id)
@@ -134,7 +144,7 @@ bool CLang::Open(CFSTR fileName, const char *id)
   char *p2 = p;
   for (unsigned i = 0; i < len; i++)
   {
-    char c = p[i];
+    const char c = p[i];
     if (c == 0)
       break;
     if (c != 0x0D)
@@ -156,7 +166,7 @@ bool CLang::Open(CFSTR fileName, const char *id)
 
 const wchar_t *CLang::Get(UInt32 id) const throw()
 {
-  int index = _ids.FindInSorted(id);
+  const int index = _ids.FindInSorted(id);
   if (index < 0)
     return NULL;
   return _text + (size_t)_offsets[(unsigned)index];
diff --git a/CPP/Common/Lang.h b/CPP/Common/Lang.h
index cc66677..76d5418 100644
--- a/CPP/Common/Lang.h
+++ b/CPP/Common/Lang.h
@@ -1,23 +1,30 @@
 // Common/Lang.h
 
-#ifndef __COMMON_LANG_H
-#define __COMMON_LANG_H
+#ifndef ZIP7_INC_COMMON_LANG_H
+#define ZIP7_INC_COMMON_LANG_H
 
 #include "MyString.h"
 
 class CLang
 {
   wchar_t *_text;
-  CRecordVector<UInt32> _ids;
-  CRecordVector<UInt32> _offsets;
 
   bool OpenFromString(const AString &s);
 public:
-  CLang(): _text(0) {}
+  CRecordVector<UInt32> _ids;
+  CRecordVector<UInt32> _offsets;
+  UStringVector Comments;
+
+  CLang(): _text(NULL) {}
   ~CLang() { Clear(); }
   bool Open(CFSTR fileName, const char *id);
   void Clear() throw();
+  bool IsEmpty() const { return _ids.IsEmpty(); }
   const wchar_t *Get(UInt32 id) const throw();
+  const wchar_t *Get_by_index(unsigned index) const throw()
+  {
+    return _text + (size_t)_offsets[index];
+  }
 };
 
 #endif
diff --git a/CPP/Common/ListFileUtils.cpp b/CPP/Common/ListFileUtils.cpp
index b361b37..e43dbc9 100644
--- a/CPP/Common/ListFileUtils.cpp
+++ b/CPP/Common/ListFileUtils.cpp
@@ -66,7 +66,7 @@ bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePag
   if (fileSize >= ((UInt32)1 << 31) - 32)
     return false;
   UString u;
-  if (codePage == MY__CP_UTF16 || codePage == MY__CP_UTF16BE)
+  if (codePage == Z7_WIN_CP_UTF16 || codePage == Z7_WIN_CP_UTF16BE)
   {
     if ((fileSize & 1) != 0)
       return false;
@@ -78,7 +78,7 @@ bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePag
     file.Close();
     const unsigned num = (unsigned)fileSize / 2;
     wchar_t *p = u.GetBuf(num);
-    if (codePage == MY__CP_UTF16)
+    if (codePage == Z7_WIN_CP_UTF16)
       for (unsigned i = 0; i < num; i++)
       {
         wchar_t c = GetUi16(buf + (size_t)i * 2);
diff --git a/CPP/Common/ListFileUtils.h b/CPP/Common/ListFileUtils.h
index a91e4b1..d43cc37 100644
--- a/CPP/Common/ListFileUtils.h
+++ b/CPP/Common/ListFileUtils.h
@@ -1,13 +1,13 @@
 // Common/ListFileUtils.h
 
-#ifndef __COMMON_LIST_FILE_UTILS_H
-#define __COMMON_LIST_FILE_UTILS_H
+#ifndef ZIP7_INC_COMMON_LIST_FILE_UTILS_H
+#define ZIP7_INC_COMMON_LIST_FILE_UTILS_H
 
 #include "MyString.h"
 #include "MyTypes.h"
 
-#define MY__CP_UTF16   1200
-#define MY__CP_UTF16BE 1201
+#define Z7_WIN_CP_UTF16   1200
+#define Z7_WIN_CP_UTF16BE 1201
 
 // bool ReadNamesFromListFile(CFSTR fileName, UStringVector &strings, UINT codePage = CP_OEMCP);
 
diff --git a/CPP/Common/MyBuffer.h b/CPP/Common/MyBuffer.h
index 18ab6fa..bc829f4 100644
--- a/CPP/Common/MyBuffer.h
+++ b/CPP/Common/MyBuffer.h
@@ -1,13 +1,15 @@
 // Common/MyBuffer.h
 
-#ifndef __COMMON_MY_BUFFER_H
-#define __COMMON_MY_BUFFER_H
+#ifndef ZIP7_INC_COMMON_MY_BUFFER_H
+#define ZIP7_INC_COMMON_MY_BUFFER_H
+
+#include <string.h>
 
 #include "Defs.h"
 #include "MyTypes.h"
 
 /* 7-Zip now uses CBuffer only as CByteBuffer.
-   So there is no need to use MY_ARRAY_NEW macro in CBuffer code. */
+   So there is no need to use Z7_ARRAY_NEW macro in CBuffer code. */
 
 template <class T> class CBuffer
 {
@@ -20,16 +22,23 @@ public:
     if (_items)
     {
       delete []_items;
-      _items = 0;
+      _items = NULL;
     }
     _size = 0;
   }
   
-  CBuffer(): _items(0), _size(0) {};
-  CBuffer(size_t size): _items(0), _size(0) { _items = new T[size]; _size = size; }
-  CBuffer(const CBuffer &buffer): _items(0), _size(0)
+  CBuffer(): _items(NULL), _size(0) {}
+  CBuffer(size_t size): _items(NULL), _size(0)
+  {
+    if (size != 0)
+    {
+      _items = new T[size];
+      _size = size;
+    }
+  }
+  CBuffer(const CBuffer &buffer): _items(NULL), _size(0)
   {
-    size_t size = buffer._size;
+    const size_t size = buffer._size;
     if (size != 0)
     {
       _items = new T[size];
@@ -136,7 +145,7 @@ typedef CBuffer<unsigned char> CByteBuffer;
 
 class CByteBuffer_Wipe: public CByteBuffer
 {
-  CLASS_NO_COPY(CByteBuffer_Wipe)
+  Z7_CLASS_NO_COPY(CByteBuffer_Wipe)
 public:
   // CByteBuffer_Wipe(): CBuffer<unsigned char>() {}
   CByteBuffer_Wipe(size_t size): CBuffer<unsigned char>(size) {}
@@ -157,17 +166,17 @@ public:
   void Free()
   {
     delete []_items;
-    _items = 0;
+    _items = NULL;
   }
-  CObjArray(size_t size): _items(0)
+  CObjArray(size_t size): _items(NULL)
   {
     if (size != 0)
     {
-      MY_ARRAY_NEW(_items, T, size)
+      Z7_ARRAY_NEW(_items, T, size)
       // _items = new T[size];
     }
   }
-  CObjArray(): _items(0) {};
+  CObjArray(): _items(NULL) {}
   ~CObjArray() { delete []_items; }
   
   operator       T *()       { return _items; }
@@ -176,8 +185,8 @@ public:
   void Alloc(size_t newSize)
   {
     delete []_items;
-    _items = 0;
-    MY_ARRAY_NEW(_items, T, newSize)
+    _items = NULL;
+    Z7_ARRAY_NEW(_items, T, newSize)
     // _items = new T[newSize];
   }
 };
@@ -201,12 +210,12 @@ public:
   void Free()
   {
     delete []_items;
-    _items = 0;
+    _items = NULL;
     _size = 0;
   }
-  CObjArray2(): _items(0), _size(0) {};
+  CObjArray2(): _items(NULL), _size(0) {}
   /*
-  CObjArray2(const CObjArray2 &buffer): _items(0), _size(0)
+  CObjArray2(const CObjArray2 &buffer): _items(NULL), _size(0)
   {
     size_t newSize = buffer._size;
     if (newSize != 0)
@@ -221,7 +230,7 @@ public:
   }
   */
   /*
-  CObjArray2(size_t size): _items(0), _size(0)
+  CObjArray2(size_t size): _items(NULL), _size(0)
   {
     if (size != 0)
     {
@@ -247,7 +256,7 @@ public:
     T *newBuffer = NULL;
     if (size != 0)
     {
-      MY_ARRAY_NEW(newBuffer, T, size)
+      Z7_ARRAY_NEW(newBuffer, T, size)
       // newBuffer = new T[size];
     }
     delete []_items;
diff --git a/CPP/Common/MyBuffer2.h b/CPP/Common/MyBuffer2.h
index 372d478..23394f8 100644
--- a/CPP/Common/MyBuffer2.h
+++ b/CPP/Common/MyBuffer2.h
@@ -1,7 +1,7 @@
 // Common/MyBuffer2.h
 
-#ifndef __COMMON_MY_BUFFER2_H
-#define __COMMON_MY_BUFFER2_H
+#ifndef ZIP7_INC_COMMON_MY_BUFFER2_H
+#define ZIP7_INC_COMMON_MY_BUFFER2_H
 
 #include "../../C/Alloc.h"
 
@@ -12,7 +12,7 @@ class CMidBuffer
   Byte *_data;
   size_t _size;
 
-  CLASS_NO_COPY(CMidBuffer)
+  Z7_CLASS_NO_COPY(CMidBuffer)
 
 public:
   CMidBuffer(): _data(NULL), _size(0) {}
@@ -56,12 +56,37 @@ public:
 };
 
 
+class CAlignedBuffer1
+{
+  Byte *_data;
+
+  Z7_CLASS_NO_COPY(CAlignedBuffer1)
+
+public:
+  ~CAlignedBuffer1()
+  {
+    ISzAlloc_Free(&g_AlignedAlloc, _data);
+  }
+
+  CAlignedBuffer1(size_t size)
+  {
+    _data = NULL;
+    _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+    if (!_data)
+      throw 1;
+  }
+
+  operator       Byte *()       { return _data; }
+  operator const Byte *() const { return _data; }
+};
+
+
 class CAlignedBuffer
 {
   Byte *_data;
   size_t _size;
 
-  CLASS_NO_COPY(CAlignedBuffer)
+  Z7_CLASS_NO_COPY(CAlignedBuffer)
 
 public:
   CAlignedBuffer(): _data(NULL), _size(0) {}
diff --git a/CPP/Common/MyCom.h b/CPP/Common/MyCom.h
index ff54278..65c4330 100644
--- a/CPP/Common/MyCom.h
+++ b/CPP/Common/MyCom.h
@@ -1,15 +1,11 @@
 // MyCom.h
 
-#ifndef __MY_COM_H
-#define __MY_COM_H
+#ifndef ZIP7_INC_MY_COM_H
+#define ZIP7_INC_MY_COM_H
 
 #include "MyWindows.h"
 #include "MyTypes.h"
 
-#ifndef RINOK
-#define RINOK(x) { HRESULT __result_ = (x); if (__result_ != S_OK) return __result_; }
-#endif
-
 template <class T>
 class CMyComPtr
 {
@@ -72,6 +68,10 @@ public:
   }
 };
 
+#define Z7_DECL_CMyComPtr_QI_FROM(i, v, unk) \
+  CMyComPtr<i> v; (unk)->QueryInterface(IID_ ## i, (void **)&v);
+
+
 //////////////////////////////////////////////////////////
 
 inline HRESULT StringToBstr(LPCOLESTR src, BSTR *bstr)
@@ -83,7 +83,7 @@ inline HRESULT StringToBstr(LPCOLESTR src, BSTR *bstr)
 class CMyComBSTR
 {
   BSTR m_str;
-  CLASS_NO_COPY(CMyComBSTR)
+  Z7_CLASS_NO_COPY(CMyComBSTR)
 public:
   CMyComBSTR(): m_str(NULL) {}
   ~CMyComBSTR() { ::SysFreeString(m_str); }
@@ -174,7 +174,7 @@ private:
 
 class CMyComBSTR_Wipe: public CMyComBSTR
 {
-  CLASS_NO_COPY(CMyComBSTR_Wipe)
+  Z7_CLASS_NO_COPY(CMyComBSTR_Wipe)
 public:
   CMyComBSTR_Wipe(): CMyComBSTR() {}
   ~CMyComBSTR_Wipe() { Wipe_and_Free(); }
@@ -185,123 +185,325 @@ public:
 /*
   If CMyUnknownImp doesn't use virtual destructor, the code size is smaller.
   But if some class_1 derived from CMyUnknownImp
-    uses MY_ADDREF_RELEASE and IUnknown::Release()
+    uses Z7_COM_ADDREF_RELEASE and IUnknown::Release()
     and some another class_2 is derived from class_1,
     then class_1 must use virtual destructor:
       virtual ~class_1();
     In that case, class_1::Release() calls correct destructor of class_2.
-
-  We use virtual ~CMyUnknownImp() to disable warning
+  We can use virtual ~CMyUnknownImp() to disable warning
     "class has virtual functions, but destructor is not virtual".
-
-  also we can use virtual ~IUnknown() {} in MyWindows.h
+  Also we can use virtual ~IUnknown() {} in MyWindows.h
 */
 
 class CMyUnknownImp
 {
-  CLASS_NO_COPY(CMyUnknownImp)
-public:
-  ULONG __m_RefCount;
-  CMyUnknownImp(): __m_RefCount(0) {}
+  Z7_CLASS_NO_COPY(CMyUnknownImp)
+protected:
+  ULONG _m_RefCount;
+  CMyUnknownImp(): _m_RefCount(0) {}
 
   #ifdef _WIN32
   #if defined(__GNUC__) || defined(__clang__)
-  virtual // to disable GCC/CLANG varnings
+  // virtual ~CMyUnknownImp() {} // to disable GCC/CLANG varnings
   #endif
   #endif
-  ~CMyUnknownImp() {}
 };
 
 
 
-#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \
-(REFGUID iid, void **outObject) throw() { *outObject = NULL;
+#define Z7_COM_QI_BEGIN \
+  private: STDMETHOD(QueryInterface) (REFGUID iid, void **outObject) throw() Z7_override Z7_final \
+    { *outObject = NULL;
+
+#define Z7_COM_QI_ENTRY(i) \
+  else if (iid == IID_ ## i) \
+    { i *ti = this;  *outObject = ti; }
+//   { *outObject = (void *)(i *)this; }
 
-#define MY_QUERYINTERFACE_ENTRY(i) else if (iid == IID_ ## i) \
-    { *outObject = (void *)(i *)this; }
+#define Z7_COM_QI_ENTRY_UNKNOWN_0 \
+  if (iid == IID_IUnknown) \
+    { IUnknown *tu = this;  *outObject = tu; }
 
-#define MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) if (iid == IID_IUnknown) \
-    { *outObject = (void *)(IUnknown *)(i *)this; }
+#define Z7_COM_QI_ENTRY_UNKNOWN(i) \
+  if (iid == IID_IUnknown) \
+    { i *ti = this;  IUnknown *tu = ti;  *outObject = tu; }
+//    { *outObject = (void *)(IUnknown *)(i *)this; }
 
-#define MY_QUERYINTERFACE_BEGIN2(i) MY_QUERYINTERFACE_BEGIN \
-    MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) \
-    MY_QUERYINTERFACE_ENTRY(i)
+#define Z7_COM_QI_BEGIN2(i) \
+  Z7_COM_QI_BEGIN \
+  Z7_COM_QI_ENTRY_UNKNOWN(i) \
+  Z7_COM_QI_ENTRY(i)
 
-#define MY_QUERYINTERFACE_END else return E_NOINTERFACE; ++__m_RefCount; /* AddRef(); */ return S_OK; }
+#define Z7_COM_QI_END \
+  else return E_NOINTERFACE; \
+  ++_m_RefCount; /* AddRef(); */ return S_OK; }
 
-#define MY_ADDREF_RELEASE \
-STDMETHOD_(ULONG, AddRef)() throw() { return ++__m_RefCount; } \
-STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0) return __m_RefCount; \
-    delete this; return 0; }
+#define Z7_COM_ADDREF_RELEASE \
+  private: \
+  STDMETHOD_(ULONG, AddRef)() throw() Z7_override Z7_final \
+    { return ++_m_RefCount; } \
+  STDMETHOD_(ULONG, Release)() throw() Z7_override Z7_final \
+    { if (--_m_RefCount != 0) return _m_RefCount;  delete this;  return 0; } \
 
-#define MY_UNKNOWN_IMP_SPEC(i) \
-  MY_QUERYINTERFACE_BEGIN \
+#define Z7_COM_UNKNOWN_IMP_SPEC(i) \
+  Z7_COM_QI_BEGIN \
   i \
-  MY_QUERYINTERFACE_END \
-  MY_ADDREF_RELEASE
+  Z7_COM_QI_END \
+  Z7_COM_ADDREF_RELEASE
 
 
-#define MY_UNKNOWN_IMP MY_QUERYINTERFACE_BEGIN \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(IUnknown) \
-  MY_QUERYINTERFACE_END \
-  MY_ADDREF_RELEASE
+#define Z7_COM_UNKNOWN_IMP_0 \
+  Z7_COM_QI_BEGIN \
+  Z7_COM_QI_ENTRY_UNKNOWN_0 \
+  Z7_COM_QI_END \
+  Z7_COM_ADDREF_RELEASE
 
-#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i) \
-  MY_QUERYINTERFACE_ENTRY(i) \
+#define Z7_COM_UNKNOWN_IMP_1(i) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i) \
+  Z7_COM_QI_ENTRY(i) \
   )
 
-#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
+#define Z7_COM_UNKNOWN_IMP_2(i1, i2) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
   )
 
-#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
-  MY_QUERYINTERFACE_ENTRY(i3) \
+#define Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
   )
 
-#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
-  MY_QUERYINTERFACE_ENTRY(i3) \
-  MY_QUERYINTERFACE_ENTRY(i4) \
+#define Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
+  Z7_COM_QI_ENTRY(i4) \
   )
 
-#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
-  MY_QUERYINTERFACE_ENTRY(i3) \
-  MY_QUERYINTERFACE_ENTRY(i4) \
-  MY_QUERYINTERFACE_ENTRY(i5) \
+#define Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
+  Z7_COM_QI_ENTRY(i4) \
+  Z7_COM_QI_ENTRY(i5) \
   )
 
-#define MY_UNKNOWN_IMP6(i1, i2, i3, i4, i5, i6) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
-  MY_QUERYINTERFACE_ENTRY(i3) \
-  MY_QUERYINTERFACE_ENTRY(i4) \
-  MY_QUERYINTERFACE_ENTRY(i5) \
-  MY_QUERYINTERFACE_ENTRY(i6) \
+#define Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
+  Z7_COM_QI_ENTRY(i4) \
+  Z7_COM_QI_ENTRY(i5) \
+  Z7_COM_QI_ENTRY(i6) \
   )
 
-#define MY_UNKNOWN_IMP7(i1, i2, i3, i4, i5, i6, i7) MY_UNKNOWN_IMP_SPEC( \
-  MY_QUERYINTERFACE_ENTRY_UNKNOWN(i1) \
-  MY_QUERYINTERFACE_ENTRY(i1) \
-  MY_QUERYINTERFACE_ENTRY(i2) \
-  MY_QUERYINTERFACE_ENTRY(i3) \
-  MY_QUERYINTERFACE_ENTRY(i4) \
-  MY_QUERYINTERFACE_ENTRY(i5) \
-  MY_QUERYINTERFACE_ENTRY(i6) \
-  MY_QUERYINTERFACE_ENTRY(i7) \
+#define Z7_COM_UNKNOWN_IMP_7(i1, i2, i3, i4, i5, i6, i7) \
+  Z7_COM_UNKNOWN_IMP_SPEC( \
+  Z7_COM_QI_ENTRY_UNKNOWN(i1) \
+  Z7_COM_QI_ENTRY(i1) \
+  Z7_COM_QI_ENTRY(i2) \
+  Z7_COM_QI_ENTRY(i3) \
+  Z7_COM_QI_ENTRY(i4) \
+  Z7_COM_QI_ENTRY(i5) \
+  Z7_COM_QI_ENTRY(i6) \
+  Z7_COM_QI_ENTRY(i7) \
   )
 
-const HRESULT k_My_HRESULT_WritingWasCut = 0x20000010;
+
+#define Z7_IFACES_IMP_UNK_1(i1) \
+  Z7_COM_UNKNOWN_IMP_1(i1) \
+  Z7_IFACE_COM7_IMP(i1) \
+
+#define Z7_IFACES_IMP_UNK_2(i1, i2) \
+  Z7_COM_UNKNOWN_IMP_2(i1, i2) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+
+#define Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
+  Z7_COM_UNKNOWN_IMP_3(i1, i2, i3) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+
+#define Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
+  Z7_COM_UNKNOWN_IMP_4(i1, i2, i3, i4) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+
+#define Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
+  Z7_COM_UNKNOWN_IMP_5(i1, i2, i3, i4, i5) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+  Z7_IFACE_COM7_IMP(i5) \
+
+#define Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
+  Z7_COM_UNKNOWN_IMP_6(i1, i2, i3, i4, i5, i6) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+  Z7_IFACE_COM7_IMP(i5) \
+  Z7_IFACE_COM7_IMP(i6) \
+
+
+#define Z7_CLASS_IMP_COM_0(c) \
+  Z7_class_final(c) : \
+  public IUnknown, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_0 \
+  private:
+
+#define Z7_CLASS_IMP_COM_1(c, i1) \
+  Z7_class_final(c) : \
+  public i1, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_1(i1) \
+  private:
+
+#define Z7_CLASS_IMP_COM_2(c, i1, i2) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_2(i1, i2) \
+  private:
+
+#define Z7_CLASS_IMP_COM_3(c, i1, i2, i3) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_3(i1, i2, i3) \
+  private:
+
+#define Z7_CLASS_IMP_COM_4(c, i1, i2, i3, i4) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_4(i1, i2, i3, i4) \
+  private:
+
+#define Z7_CLASS_IMP_COM_5(c, i1, i2, i3, i4, i5) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public i5, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_5(i1, i2, i3, i4, i5) \
+  private:
+
+#define Z7_CLASS_IMP_COM_6(c, i1, i2, i3, i4, i5, i6) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public i5, \
+  public i6, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_6(i1, i2, i3, i4, i5, i6) \
+  private:
+
+
+/*
+#define Z7_CLASS_IMP_NOQIB_0(c) \
+  Z7_class_final(c) : \
+  public IUnknown, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_0 \
+  private:
+*/
+
+#define Z7_CLASS_IMP_NOQIB_1(c, i1) \
+  Z7_class_final(c) : \
+  public i1, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_0 \
+  Z7_IFACE_COM7_IMP(i1) \
+  private:
+
+#define Z7_CLASS_IMP_NOQIB_2(c, i1, i2) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_1(i2) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  private:
+
+#define Z7_CLASS_IMP_NOQIB_3(c, i1, i2, i3) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_2(i2, i3) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  private:
+
+#define Z7_CLASS_IMP_NOQIB_4(c, i1, i2, i3, i4) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_3(i2, i3, i4) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+
+/*
+#define Z7_CLASS_IMP_NOQIB_5(c, i1, i2, i3, i4, i5) \
+  Z7_class_final(c) : \
+  public i1, \
+  public i2, \
+  public i3, \
+  public i4, \
+  public i5, \
+  public CMyUnknownImp { \
+  Z7_COM_UNKNOWN_IMP_4(i2, i3, i4, i5) \
+  Z7_IFACE_COM7_IMP(i1) \
+  Z7_IFACE_COM7_IMP(i2) \
+  Z7_IFACE_COM7_IMP(i3) \
+  Z7_IFACE_COM7_IMP(i4) \
+  Z7_IFACE_COM7_IMP(i5) \
+*/
+
+
+#define Z7_CLASS_IMP_IInStream(c) \
+  class c Z7_final : \
+  public IInStream, \
+  public CMyUnknownImp { \
+  Z7_IFACES_IMP_UNK_2(ISequentialInStream, IInStream) \
+
+
+#define k_My_HRESULT_WritingWasCut 0x20000010
 
 #endif
diff --git a/CPP/Common/MyException.h b/CPP/Common/MyException.h
index f0ad111..06fbdea 100644
--- a/CPP/Common/MyException.h
+++ b/CPP/Common/MyException.h
@@ -1,7 +1,7 @@
 // Common/Exception.h
 
-#ifndef __COMMON_EXCEPTION_H
-#define __COMMON_EXCEPTION_H
+#ifndef ZIP7_INC_COMMON_EXCEPTION_H
+#define ZIP7_INC_COMMON_EXCEPTION_H
 
 #include "MyWindows.h"
 
diff --git a/CPP/Common/MyGuidDef.h b/CPP/Common/MyGuidDef.h
index 38aad6e..ab9993b 100644
--- a/CPP/Common/MyGuidDef.h
+++ b/CPP/Common/MyGuidDef.h
@@ -1,8 +1,12 @@
 // Common/MyGuidDef.h
 
+// #pragma message "Common/MyGuidDef.h"
+
 #ifndef GUID_DEFINED
 #define GUID_DEFINED
 
+// #pragma message "GUID_DEFINED"
+
 #include "MyTypes.h"
 
 typedef struct {
@@ -27,31 +31,33 @@ typedef GUID CLSID;
 #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])
+  for (unsigned i = 0; i < sizeof(g1); i++)
+    if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])
       return 0;
   return 1;
 }
 inline int operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }
 #endif
 
+#endif // GUID_DEFINED
+
+#ifndef EXTERN_C
 #ifdef __cplusplus
-  #define MY_EXTERN_C extern "C"
+  #define EXTERN_C extern "C"
 #else
-  #define MY_EXTERN_C extern
+  #define EXTERN_C extern
 #endif
-
 #endif
 
-
 #ifdef DEFINE_GUID
 #undef DEFINE_GUID
 #endif
 
 #ifdef INITGUID
   #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
-    MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+    EXTERN_C const GUID name; \
+    EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
 #else
   #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
-    MY_EXTERN_C const GUID name
+    EXTERN_C const GUID name
 #endif
diff --git a/CPP/Common/MyInitGuid.h b/CPP/Common/MyInitGuid.h
index 04d77e2..3745c79 100644
--- a/CPP/Common/MyInitGuid.h
+++ b/CPP/Common/MyInitGuid.h
@@ -1,7 +1,7 @@
 // Common/MyInitGuid.h
 
-#ifndef __COMMON_MY_INITGUID_H
-#define __COMMON_MY_INITGUID_H
+#ifndef ZIP7_INC_COMMON_MY_INITGUID_H
+#define ZIP7_INC_COMMON_MY_INITGUID_H
 
 /*
 This file must be included only to one C++ file in project before
@@ -19,31 +19,39 @@ Also we need IID_IUnknown that is initialized in some file for linking:
   Other: we define IID_IUnknown in this file
 */
 
-#ifdef __clang__
-  #pragma clang diagnostic ignored "-Wmissing-variable-declarations"
-#endif
+// #include "Common.h"
+/* vc6 without sdk needs <objbase.h> before <initguid.h>,
+   but it doesn't work in new msvc.
+   So we include full "MyWindows.h" instead of <objbase.h> */
+// #include <objbase.h>
+#include "MyWindows.h"
 
 #ifdef _WIN32
 
+#ifdef __clang__
+  // #pragma GCC diagnostic ignored "-Wmissing-variable-declarations"
+#endif
+
 #ifdef UNDER_CE
 #include <basetyps.h>
 #endif
 
-#include <InitGuid.h>
+// for vc6 without sdk we must define INITGUID here
+#define INITGUID
+#include <initguid.h>
 
 #ifdef UNDER_CE
 DEFINE_GUID(IID_IUnknown,
 0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
 #endif
 
-#else
+#else // _WIN32
 
 #define INITGUID
 #include "MyGuidDef.h"
 DEFINE_GUID(IID_IUnknown,
 0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
 
-#endif
-
+#endif // _WIN32
 
 #endif
diff --git a/CPP/Common/MyLinux.h b/CPP/Common/MyLinux.h
index 98b453c..a8454d7 100644
--- a/CPP/Common/MyLinux.h
+++ b/CPP/Common/MyLinux.h
@@ -1,7 +1,7 @@
 // MyLinux.h
 
-#ifndef __MY_LIN_LINUX_H
-#define __MY_LIN_LINUX_H
+#ifndef ZIP7_INC_COMMON_MY_LINUX_H
+#define ZIP7_INC_COMMON_MY_LINUX_H
 
 // #include "../../C/7zTypes.h"
 
diff --git a/CPP/Common/MyMap.cpp b/CPP/Common/MyMap.cpp
index 923846a..0a200f0 100644
--- a/CPP/Common/MyMap.cpp
+++ b/CPP/Common/MyMap.cpp
@@ -76,7 +76,7 @@ bool CMap32::Set(UInt32 key, UInt32 value)
       unsigned i = kNumBitsMax - 1;
       for (; GetSubBit(key, i) == GetSubBit(n.Key, i); i--);
       n.Len = (UInt16)(kNumBitsMax - (1 + i));
-      unsigned newBit = GetSubBit(key, i);
+      const unsigned newBit = GetSubBit(key, i);
       n.Values[newBit] = value;
       n.Keys[newBit] = key;
       return false;
@@ -91,7 +91,7 @@ bool CMap32::Set(UInt32 key, UInt32 value)
     bitPos -= n.Len;
     if (GetSubBits(key, bitPos, n.Len) != GetSubBits(n.Key, bitPos, n.Len))
     {
-      unsigned i = n.Len - 1;
+      unsigned i = (unsigned)n.Len - 1;
       for (; GetSubBit(key, bitPos + i) == GetSubBit(n.Key, bitPos + i); i--);
       
       CNode e2(n);
@@ -107,7 +107,7 @@ bool CMap32::Set(UInt32 key, UInt32 value)
       Nodes.Add(e2);
       return false;
     }
-    unsigned bit = GetSubBit(key, --bitPos);
+    const unsigned bit = GetSubBit(key, --bitPos);
 
     if (n.IsLeaf[bit])
     {
@@ -121,7 +121,7 @@ bool CMap32::Set(UInt32 key, UInt32 value)
      
       CNode e2;
       
-      unsigned newBit = GetSubBit(key, i);
+      const unsigned newBit = GetSubBit(key, i);
       e2.Values[newBit] = value;
       e2.Values[1 - newBit] = n.Values[bit];
       e2.IsLeaf[newBit] = e2.IsLeaf[1 - newBit] = 1;
diff --git a/CPP/Common/MyMap.h b/CPP/Common/MyMap.h
index cbcbadd..9ca5566 100644
--- a/CPP/Common/MyMap.h
+++ b/CPP/Common/MyMap.h
@@ -1,7 +1,7 @@
 // MyMap.h
 
-#ifndef __COMMON_MYMAP_H
-#define __COMMON_MYMAP_H
+#ifndef ZIP7_INC_COMMON_MY_MAP_H
+#define ZIP7_INC_COMMON_MY_MAP_H
 
 #include "MyTypes.h"
 #include "MyVector.h"
diff --git a/CPP/Common/MyString.cpp b/CPP/Common/MyString.cpp
index bf1638e..51c1c3b 100644
--- a/CPP/Common/MyString.cpp
+++ b/CPP/Common/MyString.cpp
@@ -408,7 +408,7 @@ 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);
+  MY_STRING_DELETE(_chars)
   _chars = newBuf;
   _limit = newLimit;
 }
@@ -419,9 +419,10 @@ void AString::ReAlloc2(unsigned newLimit)
   // MY_STRING_REALLOC(_chars, char, (size_t)newLimit + 1, 0);
   char *newBuf = MY_STRING_NEW_char((size_t)newLimit + 1);
   newBuf[0] = 0;
-  MY_STRING_DELETE(_chars);
+  MY_STRING_DELETE(_chars)
   _chars = newBuf;
   _limit = newLimit;
+  _len = 0;
 }
 
 void AString::SetStartLen(unsigned len)
@@ -541,7 +542,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;
   }
@@ -558,7 +559,7 @@ AString &AString::operator=(const char *s)
   if (len > _limit)
   {
     char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -575,7 +576,7 @@ AString &AString::operator=(const AString &s)
   if (len > _limit)
   {
     char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -600,7 +601,7 @@ 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);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -624,7 +625,7 @@ void AString::SetFromBstr_if_Ascii(BSTR s)
   if (len > _limit)
   {
     char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -641,6 +642,8 @@ 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+=('-'); }
 
 AString &AString::operator+=(const char *s)
 {
@@ -694,7 +697,7 @@ void AString::SetFrom(const char *s, unsigned len) // no check
   if (len > _limit)
   {
     char *newBuf = MY_STRING_NEW_char((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -766,7 +769,7 @@ int AString::ReverseFind_PathSepar() const throw()
   const char *p = _chars + _len - 1;
   for (;;)
   {
-    char c = *p;
+    const char c = *p;
     if (IS_PATH_SEPAR(c))
       return (int)(p - _chars);
     if (p == _chars)
@@ -1001,7 +1004,7 @@ 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);
   wmemcpy(newBuf, _chars, _len + 1);
-  MY_STRING_DELETE(_chars);
+  MY_STRING_DELETE(_chars)
   _chars = newBuf;
   _limit = newLimit;
 }
@@ -1012,14 +1015,15 @@ void UString::ReAlloc2(unsigned newLimit)
   // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
   wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_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 = 0;
+  _chars = NULL;
   _chars = MY_STRING_NEW_wchar_t((size_t)len + 1);
   _len = len;
   _limit = len;
@@ -1101,7 +1105,7 @@ UString operator+(const wchar_t *s1, const UString &s2) { return UString(s1, MyS
 
 UString::UString()
 {
-  _chars = 0;
+  _chars = NULL;
   _chars = MY_STRING_NEW_wchar_t(kStartStringCapacity);
   _len = 0;
   _limit = kStartStringCapacity - 1;
@@ -1163,7 +1167,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;
   }
@@ -1180,7 +1184,7 @@ UString &UString::operator=(const wchar_t *s)
   if (len > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -1197,7 +1201,7 @@ UString &UString::operator=(const UString &s)
   if (len > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -1211,7 +1215,7 @@ void UString::SetFrom(const wchar_t *s, unsigned len) // no check
   if (len > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -1249,7 +1253,7 @@ void UString::SetFromBstr(LPCOLESTR s)
   if (len > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -1289,7 +1293,7 @@ UString &UString::operator=(const char *s)
   if (len > _limit)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = newBuf;
     _limit = len;
   }
@@ -1301,6 +1305,7 @@ UString &UString::operator=(const char *s)
   return *this;
 }
 
+void UString::Add_Dot() { operator+=(L'.'); }
 void UString::Add_Space() { operator+=(L' '); }
 void UString::Add_Space_if_NotEmpty() { if (!IsEmpty()) Add_Space(); }
 
@@ -1393,31 +1398,26 @@ int UString::ReverseFind(wchar_t c) const throw()
 {
   if (_len == 0)
     return -1;
-  const wchar_t *p = _chars + _len - 1;
-  for (;;)
+  const wchar_t *p = _chars + _len;
+  do
   {
-    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()
 {
-  if (_len == 0)
-    return -1;
-  const wchar_t *p = _chars + _len - 1;
-  for (;;)
+  const wchar_t *p = _chars + _len;
+  while (p != _chars)
   {
-    wchar_t c = *p;
+    const 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()
@@ -1601,7 +1601,7 @@ void UString2::ReAlloc2(unsigned newLimit)
   // MY_STRING_REALLOC(_chars, wchar_t, newLimit + 1, 0);
   if (_chars)
   {
-    MY_STRING_DELETE(_chars);
+    MY_STRING_DELETE(_chars)
     _chars = NULL;
     // _len = 0;
   }
@@ -1651,7 +1651,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;
@@ -1669,7 +1669,7 @@ UString2 &UString2::operator=(const wchar_t *s)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars);
+      MY_STRING_DELETE(_chars)
     _chars = newBuf;
   }
   _len = len;
@@ -1684,7 +1684,7 @@ void UString2::SetFromAscii(const char *s)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars);
+      MY_STRING_DELETE(_chars)
     _chars = newBuf;
   }
   wchar_t *chars = _chars;
@@ -1703,7 +1703,7 @@ UString2 &UString2::operator=(const UString2 &s)
   {
     wchar_t *newBuf = MY_STRING_NEW_wchar_t((size_t)len + 1);
     if (_chars)
-      MY_STRING_DELETE(_chars);
+      MY_STRING_DELETE(_chars)
     _chars = newBuf;
   }
   _len = len;
@@ -1793,3 +1793,67 @@ FString us2fs(const wchar_t *s)
 }
 
 #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 += (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);
+}
diff --git a/CPP/Common/MyString.h b/CPP/Common/MyString.h
index c777c8c..e5ce18a 100644
--- a/CPP/Common/MyString.h
+++ b/CPP/Common/MyString.h
@@ -1,7 +1,7 @@
 // Common/MyString.h
 
-#ifndef __COMMON_MY_STRING_H
-#define __COMMON_MY_STRING_H
+#ifndef ZIP7_INC_COMMON_MY_STRING_H
+#define ZIP7_INC_COMMON_MY_STRING_H
 
 #include <string.h>
 
@@ -10,6 +10,7 @@
 #include <wchar.h>
 #endif
 
+#include "Common.h"
 #include "MyWindows.h"
 #include "MyTypes.h"
 #include "MyVector.h"
@@ -70,7 +71,7 @@ inline char *MyStpCpy(char *dest, const char *src)
 {
   for (;;)
   {
-    char c = *src;
+    const char c = *src;
     *dest = c;
     if (c == 0)
       return dest;
@@ -79,6 +80,13 @@ inline char *MyStpCpy(char *dest, const char *src)
   }
 }
 
+inline void MyStringCat(char *dest, const char *src)
+{
+  for (; *dest != 0; dest++);
+  while ((*dest++ = *src++) != 0);
+  // MyStringCopy(dest + MyStringLen(dest), src);
+}
+
 inline unsigned MyStringLen(const wchar_t *s)
 {
   unsigned i;
@@ -93,7 +101,9 @@ inline void MyStringCopy(wchar_t *dest, const wchar_t *src)
 
 inline void MyStringCat(wchar_t *dest, const wchar_t *src)
 {
-  MyStringCopy(dest + MyStringLen(dest), src);
+  for (; *dest != 0; dest++);
+  while ((*dest++ = *src++) != 0);
+  // MyStringCopy(dest + MyStringLen(dest), src);
 }
 
 
@@ -102,7 +112,7 @@ inline wchar_t *MyWcpCpy(wchar_t *dest, const wchar_t *src)
 {
   for (;;)
   {
-    wchar_t c = *src;
+    const wchar_t c = *src;
     *dest = c;
     if (c == 0)
       return dest;
@@ -225,7 +235,7 @@ bool StringsAreEqualNoCase_Ascii(const char *s1, const char *s2) throw();
 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const char *s2) throw();
 bool StringsAreEqualNoCase_Ascii(const wchar_t *s1, const wchar_t *s2) throw();
 
-#define MY_STRING_DELETE(_p_) delete []_p_;
+#define MY_STRING_DELETE(_p_) { delete [](_p_); }
 // #define MY_STRING_DELETE(_p_) my_delete(_p_);
 
 
@@ -312,7 +322,7 @@ public:
   explicit AString(char c);
   explicit AString(const char *s);
   AString(const AString &s);
-  ~AString() { MY_STRING_DELETE(_chars); }
+  ~AString() { MY_STRING_DELETE(_chars) }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
@@ -322,6 +332,7 @@ public:
   char *Ptr_non_const() const { return _chars; }
   const char *Ptr() const { return _chars; }
   const char *Ptr(unsigned pos) const { return _chars + pos; }
+  const char *Ptr(int pos) const { return _chars + (unsigned)pos; }
   const char *RightPtr(unsigned num) const { return _chars + _len - num; }
   char Back() const { return _chars[(size_t)_len - 1]; }
 
@@ -379,6 +390,8 @@ public:
   void Add_OptSpaced(const char *s);
   void Add_LF();
   void Add_Slash();
+  void Add_Dot();
+  void Add_Minus();
   void Add_PathSepar() { operator+=(CHAR_PATH_SEPARATOR); }
 
   AString &operator+=(const char *s);
@@ -389,6 +402,10 @@ public:
 
   void AddFrom(const char *s, unsigned len); // no check
   void SetFrom(const char *s, unsigned len); // no check
+  void SetFrom(const char* s, int len) // no check
+  {
+    SetFrom(s, (unsigned)len); // no check
+  }
   void SetFrom_CalcLen(const char *s, unsigned len);
 
   AString Mid(unsigned startIndex, unsigned count) const { return AString(count, _chars + startIndex); }
@@ -419,9 +436,13 @@ public:
   int Find(char c) const { return FindCharPosInString(_chars, c); }
   int Find(char c, unsigned startIndex) const
   {
-    int pos = FindCharPosInString(_chars + startIndex, c);
+    const int pos = FindCharPosInString(_chars + startIndex, c);
     return pos < 0 ? -1 : (int)startIndex + pos;
   }
+  int Find(char c, int startIndex) const
+  {
+    return Find(c, (unsigned)startIndex);
+  }
   
   int ReverseFind(char c) const throw();
   int ReverseFind_Dot() const throw() { return ReverseFind('.'); }
@@ -460,6 +481,11 @@ public:
       _chars[index] = 0;
     }
   }
+  void DeleteFrom(int index)
+  {
+    DeleteFrom((unsigned)index);
+  }
+
   
   void Wipe_and_Empty()
   {
@@ -474,7 +500,7 @@ public:
 
 class AString_Wipe: public AString
 {
-  CLASS_NO_COPY(AString_Wipe)
+  Z7_CLASS_NO_COPY(AString_Wipe)
 public:
   AString_Wipe(): AString() {}
   // AString_Wipe(const AString &s): AString(s) {}
@@ -582,7 +608,7 @@ public:
   explicit UString(const AString &s);
   UString(const wchar_t *s);
   UString(const UString &s);
-  ~UString() { MY_STRING_DELETE(_chars); }
+  ~UString() { MY_STRING_DELETE(_chars) }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
@@ -591,6 +617,7 @@ public:
   operator const wchar_t *() const { return _chars; }
   wchar_t *Ptr_non_const() const { return _chars; }
   const wchar_t *Ptr() const { return _chars; }
+  const wchar_t *Ptr(int pos) const { return _chars + (unsigned)pos; }
   const wchar_t *Ptr(unsigned pos) const { return _chars + pos; }
   const wchar_t *RightPtr(unsigned num) const { return _chars + _len - num; }
   wchar_t Back() const { return _chars[(size_t)_len - 1]; }
@@ -599,6 +626,14 @@ public:
 
   wchar_t *GetBuf() { return _chars; }
 
+  /*
+  wchar_t *GetBuf_GetMaxAvail(unsigned &availBufLen)
+  {
+    availBufLen = _limit;
+    return _chars;
+  }
+  */
+
   wchar_t *GetBuf(unsigned minLen)
   {
     if (minLen > _limit)
@@ -650,6 +685,7 @@ public:
   void Add_Space();
   void Add_Space_if_NotEmpty();
   void Add_LF();
+  void Add_Dot();
   void Add_PathSepar() { operator+=(WCHAR_PATH_SEPARATOR); }
 
   UString &operator+=(const wchar_t *s);
@@ -662,6 +698,7 @@ public:
 
   UString Mid(unsigned startIndex, unsigned count) const { return UString(count, _chars + startIndex); }
   UString Left(unsigned count) const { return UString(count, *this); }
+  UString Left(int count) const { return Left((unsigned)count); }
 
   // void MakeUpper() { MyStringUpper(_chars); }
   // void MakeUpper() { MyStringUpper_Ascii(_chars); }
@@ -720,10 +757,12 @@ public:
   void Replace(wchar_t oldChar, wchar_t newChar) throw();
   void Replace(const UString &oldString, const UString &newString);
 
+  void Delete(int index) throw() { Delete((unsigned)index); }
   void Delete(unsigned index) throw();
   void Delete(unsigned index, unsigned count) throw();
   void DeleteFrontal(unsigned num) throw();
   void DeleteBack() { _chars[--_len] = 0; }
+  void DeleteFrom(int index) { DeleteFrom((unsigned)index); }
   void DeleteFrom(unsigned index)
   {
     if (index < _len)
@@ -746,7 +785,7 @@ public:
 
 class UString_Wipe: public UString
 {
-  CLASS_NO_COPY(UString_Wipe)
+  Z7_CLASS_NO_COPY(UString_Wipe)
 public:
   UString_Wipe(): UString() {}
   // UString_Wipe(const UString &s): UString(s) {}
@@ -834,7 +873,7 @@ public:
   UString2(): _chars(NULL), _len(0) {}
   UString2(const wchar_t *s);
   UString2(const UString2 &s);
-  ~UString2() { if (_chars) MY_STRING_DELETE(_chars); }
+  ~UString2() { if (_chars) { MY_STRING_DELETE(_chars) } }
 
   unsigned Len() const { return _len; }
   bool IsEmpty() const { return _len == 0; }
@@ -912,7 +951,7 @@ typedef CObjectVector<CSysString> CSysStringVector;
 
 #ifdef USE_UNICODE_FSTRING
 
-  #define __FTEXT(quote) L##quote
+  #define MY_FTEXT(quote) L##quote
 
   typedef wchar_t FChar;
   typedef UString FString;
@@ -923,9 +962,9 @@ typedef CObjectVector<CSysString> CSysStringVector;
   FString fas2fs(const AString &s);
   AString fs2fas(const FChar *s);
 
-#else
+#else // USE_UNICODE_FSTRING
 
-  #define __FTEXT(quote) quote
+  #define MY_FTEXT(quote) quote
 
   typedef char FChar;
 
@@ -979,9 +1018,9 @@ typedef CObjectVector<CSysString> CSysStringVector;
   FString us2fs(const wchar_t *s);
   #define fs2fas(_x_) (_x_)
 
-#endif
+#endif // USE_UNICODE_FSTRING
 
-#define FTEXT(quote) __FTEXT(quote)
+#define FTEXT(quote) MY_FTEXT(quote)
 
 #define FCHAR_PATH_SEPARATOR FTEXT(CHAR_PATH_SEPARATOR)
 #define FSTRING_PATH_SEPARATOR FTEXT(STRING_PATH_SEPARATOR)
@@ -993,6 +1032,18 @@ typedef const FChar *CFSTR;
 
 typedef CObjectVector<FString> FStringVector;
 
+
+class CStringFinder
+{
+  AString _temp;
+public:
+  // list - is list of low case Ascii strings separated by space " ".
+  // the function returns true, if it can find exact word (str) in (list).
+  bool FindWord_In_LowCaseAsciiList_NoCase(const char *list, const wchar_t *str);
+};
+
+void SplitString(const UString &srcString, UStringVector &destStrings);
+
 #endif
 
 
@@ -1000,10 +1051,10 @@ typedef CObjectVector<FString> FStringVector;
 #if defined(_WIN32)
   // #include <wchar.h>
   // WCHAR_MAX is defined as ((wchar_t)-1)
-  #define _WCHART_IS_16BIT 1
+  #define Z7_WCHART_IS_16BIT 1
 #elif (defined(WCHAR_MAX) && (WCHAR_MAX <= 0xffff)) \
    || (defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ == 2))
-  #define _WCHART_IS_16BIT 1
+  #define Z7_WCHART_IS_16BIT 1
 #endif
 
 #if WCHAR_PATH_SEPARATOR == L'\\'
diff --git a/CPP/Common/MyTypes.h b/CPP/Common/MyTypes.h
index 71b8e7f..8f44f67 100644
--- a/CPP/Common/MyTypes.h
+++ b/CPP/Common/MyTypes.h
@@ -1,9 +1,10 @@
 // Common/MyTypes.h
 
-#ifndef __COMMON_MY_TYPES_H
-#define __COMMON_MY_TYPES_H
+#ifndef ZIP7_INC_COMMON_MY_TYPES_H
+#define ZIP7_INC_COMMON_MY_TYPES_H
 
 #include "../../C/7zTypes.h"
+#include "Common.h"
 
 typedef int HRes;
 
@@ -33,20 +34,4 @@ struct CBoolPair
   }
 };
 
-#define CLASS_NO_COPY(cls) \
-  private: \
-  cls(const cls &); \
-  cls &operator=(const cls &);
-
-class CUncopyable
-{
-protected:
-  CUncopyable() {} // allow constructor
-  // ~CUncopyable() {}
-CLASS_NO_COPY(CUncopyable)
-};
-
-#define MY_UNCOPYABLE  :private CUncopyable
-// #define MY_UNCOPYABLE
-
 #endif
diff --git a/CPP/Common/MyUnknown.h b/CPP/Common/MyUnknown.h
index ff025cb..75ee96f 100644
--- a/CPP/Common/MyUnknown.h
+++ b/CPP/Common/MyUnknown.h
@@ -1,17 +1,8 @@
 // MyUnknown.h
 
-#ifndef __MY_UNKNOWN_H
-#define __MY_UNKNOWN_H
+#ifndef ZIP7_INC_MY_UNKNOWN_H
+#define ZIP7_INC_MY_UNKNOWN_H
 
 #include "MyWindows.h"
 
-/*
-#ifdef _WIN32
-#include <basetyps.h>
-#include <unknwn.h>
-#else
-#include "MyWindows.h"
-#endif
-*/
-  
 #endif
diff --git a/CPP/Common/MyVector.h b/CPP/Common/MyVector.h
index 3417a17..9ee7105 100644
--- a/CPP/Common/MyVector.h
+++ b/CPP/Common/MyVector.h
@@ -1,10 +1,12 @@
 // Common/MyVector.h
 
-#ifndef __COMMON_MY_VECTOR_H
-#define __COMMON_MY_VECTOR_H
+#ifndef ZIP7_INC_COMMON_MY_VECTOR_H
+#define ZIP7_INC_COMMON_MY_VECTOR_H
 
 #include <string.h>
 
+#include "Common.h"
+
 const unsigned k_VectorSizeMax = ((unsigned)1 << 31) - 1;
 
 template <class T>
@@ -22,7 +24,7 @@ class CRecordVector
   void ReAllocForNewCapacity(const unsigned newCapacity)
   {
     T *p;
-    MY_ARRAY_NEW(p, T, newCapacity);
+    Z7_ARRAY_NEW(p, T, newCapacity)
     // p = new T[newCapacity];
     if (_size != 0)
       memcpy(p, _items, (size_t)_size * sizeof(T));
@@ -53,7 +55,7 @@ public:
     const unsigned size = v.Size();
     if (size != 0)
     {
-      // MY_ARRAY_NEW(_items, T, size)
+      // Z7_ARRAY_NEW(_items, T, size)
       _items = new T[size];
       _size = size;
       _capacity = size;
@@ -68,7 +70,7 @@ public:
   {
     if (size != 0)
     {
-      MY_ARRAY_NEW(_items, T, size)
+      Z7_ARRAY_NEW(_items, T, size)
       // _items = new T[size];
       _capacity = size;
     }
@@ -100,7 +102,7 @@ public:
       delete []_items;
       _items = NULL;
       _capacity = 0;
-      MY_ARRAY_NEW(_items, T, newCapacity)
+      Z7_ARRAY_NEW(_items, T, newCapacity)
       // _items = new T[newCapacity];
       _capacity = newCapacity;
     }
@@ -119,7 +121,7 @@ public:
     T *p = NULL;
     if (_size != 0)
     {
-      // MY_ARRAY_NEW(p, T, _size)
+      // Z7_ARRAY_NEW(p, T, _size)
       p = new T[_size];
       memcpy(p, _items, (size_t)_size * sizeof(T));
     }
@@ -264,6 +266,8 @@ public:
 
   const T& operator[](unsigned index) const { return _items[index]; }
         T& operator[](unsigned index)       { return _items[index]; }
+  const T& operator[](int index) const { return _items[(unsigned)index]; }
+        T& operator[](int index)       { return _items[(unsigned)index]; }
   const T& Front() const { return _items[0]; }
         T& Front()       { return _items[0]; }
   const T& Back() const  { return _items[(size_t)_size - 1]; }
@@ -497,6 +501,8 @@ public:
   
   const T& operator[](unsigned index) const { return *((T *)_v[index]); }
         T& operator[](unsigned index)       { return *((T *)_v[index]); }
+  const T& operator[](int index) const { return *((T *)_v[(unsigned)index]); }
+        T& operator[](int index)       { return *((T *)_v[(unsigned)index]); }
   const T& Front() const { return operator[](0); }
         T& Front()       { return operator[](0); }
   const T& Back() const  { return *(T *)_v.Back(); }
@@ -604,6 +610,7 @@ public:
     delete (T *)_v[index];
     _v.Delete(index);
   }
+  // void Delete(int index) { Delete((unsigned)index); }
 
   /*
   void Delete(unsigned index, unsigned num)
diff --git a/CPP/Common/MyWindows.cpp b/CPP/Common/MyWindows.cpp
index 88f312f..ae284eb 100644
--- a/CPP/Common/MyWindows.cpp
+++ b/CPP/Common/MyWindows.cpp
@@ -78,7 +78,7 @@ BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
 BSTR SysAllocString(const OLECHAR *s)
 {
   if (!s)
-    return 0;
+    return NULL;
   const OLECHAR *s2 = s;
   while (*s2 != 0)
     s2++;
@@ -181,7 +181,7 @@ BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFil
 {
   UInt64 v = GET_TIME_64(fileTime);
   v = (UInt64)((Int64)v - (Int64)TIME_GetBias() * TICKS_PER_SEC);
-  SET_FILETIME(localFileTime, v);
+  SET_FILETIME(localFileTime, v)
   return TRUE;
 }
 
@@ -189,7 +189,7 @@ BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fil
 {
   UInt64 v = GET_TIME_64(localFileTime);
   v = (UInt64)((Int64)v + (Int64)TIME_GetBias() * TICKS_PER_SEC);
-  SET_FILETIME(fileTime, v);
+  SET_FILETIME(fileTime, v)
   return TRUE;
 }
 
@@ -203,7 +203,7 @@ VOID WINAPI GetSystemTimeAsFileTime(FILETIME *ft)
     t = tv.tv_sec * (UInt64)TICKS_PER_SEC + TICKS_1601_TO_1970;
     t += tv.tv_usec * 10;
   }
-  SET_FILETIME(ft, t);
+  SET_FILETIME(ft, t)
 }
 */
 
diff --git a/CPP/Common/MyWindows.h b/CPP/Common/MyWindows.h
index 15db524..a76e14b 100644
--- a/CPP/Common/MyWindows.h
+++ b/CPP/Common/MyWindows.h
@@ -1,16 +1,25 @@
 // MyWindows.h
 
-#ifndef __MY_WINDOWS_H
-#define __MY_WINDOWS_H
+#ifdef Z7_DEFINE_GUID
+#undef Z7_DEFINE_GUID
+#endif
 
-#ifdef _WIN32
+#ifdef INITGUID
+  #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name; \
+    EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+  #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name
+#endif
 
-#include <Windows.h>
 
-#ifdef UNDER_CE
-  #undef VARIANT_TRUE
-  #define VARIANT_TRUE ((VARIANT_BOOL)-1)
-#endif
+#ifndef ZIP7_INC_MY_WINDOWS_H
+#define ZIP7_INC_MY_WINDOWS_H
+
+#ifdef _WIN32
+
+#include "../../C/7zWindows.h"
 
 #else // _WIN32
 
@@ -18,11 +27,11 @@
 #include <string.h>
 // #include <stdint.h> // for uintptr_t
 
+#include "../../C/7zTypes.h"
 #include "MyGuidDef.h"
 
 // WINAPI is __stdcall in Windows-MSVC in windef.h
 #define WINAPI
-#define EXTERN_C MY_EXTERN_C
 
 typedef char CHAR;
 typedef unsigned char UCHAR;
@@ -103,31 +112,78 @@ typedef LONG SCODE;
 
 #define STDAPI  EXTERN_C HRESULT STDAPICALLTYPE
 
-#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f
-#define STDMETHOD(f) STDMETHOD_(HRESULT, f)
-#define STDMETHODIMP_(type) type STDMETHODCALLTYPE
-#define STDMETHODIMP STDMETHODIMP_(HRESULT)
+#ifndef DECLSPEC_NOTHROW
+#define DECLSPEC_NOTHROW    Z7_DECLSPEC_NOTHROW
+#endif
+
+#ifndef DECLSPEC_NOVTABLE
+#define DECLSPEC_NOVTABLE   Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifndef COM_DECLSPEC_NOTHROW
+#ifdef COM_STDMETHOD_CAN_THROW
+  #define COM_DECLSPEC_NOTHROW
+#else
+  #define COM_DECLSPEC_NOTHROW  DECLSPEC_NOTHROW
+#endif
+#endif
+
+#define DECLARE_INTERFACE(iface)              struct DECLSPEC_NOVTABLE iface
+#define DECLARE_INTERFACE_(iface, baseiface)  struct DECLSPEC_NOVTABLE iface : public baseiface
+
+#define STDMETHOD_(t, f)  virtual COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE f
+#define STDMETHOD(f)      STDMETHOD_(HRESULT, f)
+#define STDMETHODIMP_(t)  COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE
+#define STDMETHODIMP      STDMETHODIMP_(HRESULT)
+
 
 #define PURE = 0
 
-#define MIDL_INTERFACE(x) struct
+// #define MIDL_INTERFACE(x) struct
+
 
 #ifdef __cplusplus
 
+/*
+  p7zip and 7-Zip before v23 used virtual destructor in IUnknown,
+  if _WIN32 is not defined.
+  It used virtual destructor, because some compilers don't like virtual
+  interfaces without virtual destructor.
+  IUnknown in Windows (_WIN32) doesn't use virtual destructor in IUnknown.
+  We still can define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+  if we want to be compatible with old plugin interface of p7zip and 7-Zip before v23.
+
+v23:
+  In new 7-Zip v23 we try to be more compatible with original IUnknown from _WIN32.
+  So we do not define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+*/
+// #define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+
+#ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Winconsistent-missing-destructor-override"
+#endif
+#endif
+
+Z7_PURE_INTERFACES_BEGIN
+
 DEFINE_GUID(IID_IUnknown,
 0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
 struct IUnknown
 {
-  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;
-  STDMETHOD_(ULONG, AddRef)() PURE;
-  STDMETHOD_(ULONG, Release)() PURE;
+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) =0;
+  STDMETHOD_(ULONG, AddRef)() =0;
+  STDMETHOD_(ULONG, Release)() =0;
+ #ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
   virtual ~IUnknown() {}
-  // We use virtual ~IUnknown() here for binary compatibility with 7z.so from p7zip
+ #endif
 };
 
 typedef IUnknown *LPUNKNOWN;
 
-#endif
+Z7_PURE_INTERFACES_END
+
+#endif // __cplusplus
 
 #define VARIANT_TRUE ((VARIANT_BOOL)-1)
 #define VARIANT_FALSE ((VARIANT_BOOL)0)
@@ -197,8 +253,8 @@ typedef PROPVARIANT tagVARIANT;
 typedef tagVARIANT VARIANT;
 typedef VARIANT VARIANTARG;
 
-MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
-MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src);
+EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
+EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src);
 
 typedef struct tagSTATPROPSTG
 {
@@ -207,19 +263,19 @@ typedef struct tagSTATPROPSTG
   VARTYPE vt;
 } STATPROPSTG;
 
-MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
-MY_EXTERN_C BSTR SysAllocStringLen(const OLECHAR *sz, UINT len);
-MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
-MY_EXTERN_C void SysFreeString(BSTR bstr);
-MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);
-MY_EXTERN_C UINT SysStringLen(BSTR bstr);
+EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+EXTERN_C BSTR SysAllocStringLen(const OLECHAR *sz, UINT len);
+EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
+EXTERN_C void SysFreeString(BSTR bstr);
+EXTERN_C UINT SysStringByteLen(BSTR bstr);
+EXTERN_C UINT SysStringLen(BSTR bstr);
 
-MY_EXTERN_C DWORD GetLastError();
-MY_EXTERN_C void SetLastError(DWORD dwCode);
-MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
+EXTERN_C DWORD GetLastError();
+EXTERN_C void SetLastError(DWORD dwCode);
+EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
 
-MY_EXTERN_C DWORD GetCurrentThreadId();
-MY_EXTERN_C DWORD GetCurrentProcessId();
+EXTERN_C DWORD GetCurrentThreadId();
+EXTERN_C DWORD GetCurrentProcessId();
 
 #define MAX_PATH 1024
 
diff --git a/CPP/Common/MyXml.cpp b/CPP/Common/MyXml.cpp
index e014518..a879d34 100644
--- a/CPP/Common/MyXml.cpp
+++ b/CPP/Common/MyXml.cpp
@@ -81,7 +81,7 @@ AString CXmlItem::GetSubStringForTag(const char *tag) const
 
 const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
 {
-  SKIP_SPACES(s);
+  SKIP_SPACES(s)
 
   const char *beg = s;
   for (;;)
@@ -102,7 +102,7 @@ const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
   IsTag = true;
 
   s++;
-  SKIP_SPACES(s);
+  SKIP_SPACES(s)
 
   beg = s;
   for (;; s++)
@@ -115,11 +115,11 @@ const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
   for (;;)
   {
     beg = s;
-    SKIP_SPACES(s);
+    SKIP_SPACES(s)
     if (*s == '/')
     {
       s++;
-      // SKIP_SPACES(s);
+      // SKIP_SPACES(s)
       if (*s != '>')
         return NULL;
       return s + 1;
@@ -132,7 +132,7 @@ const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
       SubItems.Clear();
       for (;;)
       {
-        SKIP_SPACES(s);
+        SKIP_SPACES(s)
         if (s[0] == '<' && s[1] == '/')
           break;
         CXmlItem &item = SubItems.AddNew();
@@ -168,11 +168,11 @@ const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
       return NULL;
     prop.Name.SetFrom(beg, (unsigned)(s - beg));
     
-    SKIP_SPACES(s);
+    SKIP_SPACES(s)
     if (*s != '=')
       return NULL;
     s++;
-    SKIP_SPACES(s);
+    SKIP_SPACES(s)
     if (*s != '\"')
       return NULL;
     s++;
@@ -194,7 +194,7 @@ const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
 
 static const char * SkipHeader(const char *s, const char *startString, const char *endString)
 {
-  SKIP_SPACES(s);
+  SKIP_SPACES(s)
   if (IsString1PrefixedByString2(s, startString))
   {
     s = strstr(s, endString);
@@ -215,7 +215,7 @@ void CXmlItem::AppendTo(AString &s) const
     FOR_VECTOR (i, Props)
     {
       const CXmlProp &prop = Props[i];
-      s += ' ';
+      s.Add_Space();
       s += prop.Name;
       s += '=';
       s += '\"';
@@ -228,7 +228,7 @@ void CXmlItem::AppendTo(AString &s) const
   {
     const CXmlItem &item = SubItems[i];
     if (i != 0 && !SubItems[i - 1].IsTag)
-      s += ' ';
+      s.Add_Space();
     item.AppendTo(s);
   }
   if (IsTag)
@@ -248,7 +248,7 @@ bool CXml::Parse(const char *s)
   s = Root.ParseItem(s, 1000);
   if (!s || !Root.IsTag)
     return false;
-  SKIP_SPACES(s);
+  SKIP_SPACES(s)
   return *s == 0;
 }
 
diff --git a/CPP/Common/MyXml.h b/CPP/Common/MyXml.h
index 00b7113..5362602 100644
--- a/CPP/Common/MyXml.h
+++ b/CPP/Common/MyXml.h
@@ -1,7 +1,7 @@
 // MyXml.h
 
-#ifndef __MY_XML_H
-#define __MY_XML_H
+#ifndef ZIP7_INC_MY_XML_H
+#define ZIP7_INC_MY_XML_H
 
 #include "MyString.h"
 
diff --git a/CPP/Common/NewHandler.cpp b/CPP/Common/NewHandler.cpp
index 65ef41d..c95833e 100644
--- a/CPP/Common/NewHandler.cpp
+++ b/CPP/Common/NewHandler.cpp
@@ -10,21 +10,23 @@
 
 #ifndef DEBUG_MEMORY_LEAK
 
-#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
+#ifdef Z7_REDEFINE_OPERATOR_NEW
 
 /*
 void * my_new(size_t size)
 {
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  if (size == 0)
+    size = 1;
   void *p = ::malloc(size);
-  if (p == 0)
+  if (!p)
     throw CNewException();
   return p;
 }
 
 void my_delete(void *p) throw()
 {
-  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
   ::free(p);
 }
 
@@ -44,9 +46,21 @@ __cdecl
 #endif
 operator new(size_t size)
 {
+  /* by C++ specification:
+       if (size == 0), operator new(size) returns non_NULL pointer.
+     If (operator new(0) returns NULL), it's out of specification.
+       but some calling code can work correctly even in this case too. */
+  // if (size == 0) return NULL; // for debug only. don't use it
+
+  /* malloc(0) returns non_NULL in main compilers, as we need here.
+     But specification also allows malloc(0) to return NULL.
+     So we change (size=0) to (size=1) here to get real non_NULL pointer */
+  if (size == 0)
+    size = 1;
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  // void *p = ::MyAlloc(size);  // note: MyAlloc(0) returns NULL
   void *p = ::malloc(size);
-  if (p == 0)
+  if (!p)
     throw CNewException();
   return p;
 }
@@ -57,7 +71,8 @@ __cdecl
 #endif
 operator delete(void *p) throw()
 {
-  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // MyFree(p);
   ::free(p);
 }
 
@@ -69,8 +84,10 @@ __cdecl
 operator new[](size_t size)
 {
   // void *p = ::HeapAlloc(::GetProcessHeap(), 0, size);
+  if (size == 0)
+    size = 1;
   void *p = ::malloc(size);
-  if (p == 0)
+  if (!p)
     throw CNewException();
   return p;
 }
@@ -81,7 +98,7 @@ __cdecl
 #endif
 operator delete[](void *p) throw()
 {
-  // if (p == 0) return; ::HeapFree(::GetProcessHeap(), 0, p);
+  // if (!p) return; ::HeapFree(::GetProcessHeap(), 0, p);
   ::free(p);
 }
 */
@@ -93,16 +110,43 @@ operator delete[](void *p) throw()
 #include <stdio.h>
 
 // #pragma init_seg(lib)
+/*
 const int kDebugSize = 1000000;
 static void *a[kDebugSize];
-static int index = 0;
+static int g_index = 0;
+
+class CC
+{
+public:
+  CC()
+  {
+    for (int i = 0; i < kDebugSize; i++)
+      a[i] = 0;
+  }
+  ~CC()
+  {
+    printf("\nDestructor: %d\n", numAllocs);
+    for (int i = 0; i < kDebugSize; i++)
+      if (a[i] != 0)
+        return;
+  }
+} g_CC;
+*/
 
+#ifdef _WIN32
 static bool wasInit = false;
 static CRITICAL_SECTION cs;
+#endif
 
 static int numAllocs = 0;
-void * __cdecl operator new(size_t size)
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size)
 {
+ #ifdef _WIN32
   if (!wasInit)
   {
     InitializeCriticalSection(&cs);
@@ -114,52 +158,126 @@ void * __cdecl operator new(size_t size)
   int loc = numAllocs;
   void *p = HeapAlloc(GetProcessHeap(), 0, size);
   /*
-  if (index < kDebugSize)
+  if (g_index < kDebugSize)
   {
-    a[index] = p;
-    index++;
+    a[g_index] = p;
+    g_index++;
   }
   */
   printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
   LeaveCriticalSection(&cs);
-  if (p == 0)
+  if (!p)
     throw CNewException();
   return p;
-}
-
-class CC
-{
-public:
-  CC()
-  {
-    for (int i = 0; i < kDebugSize; i++)
-      a[i] = 0;
-  }
-  ~CC()
+ #else
+  numAllocs++;
+  int loc = numAllocs;
+  if (size == 0)
+    size = 1;
+  void *p = malloc(size);
+  /*
+  if (g_index < kDebugSize)
   {
-    printf("\nDestructor: %d\n", numAllocs);
-    for (int i = 0; i < kDebugSize; i++)
-      if (a[i] != 0)
-        return;
+    a[g_index] = p;
+    g_index++;
   }
-} g_CC;
-
+  */
+  printf("Alloc %6d, size = %8u\n", loc, (unsigned)size);
+  if (!p)
+    throw CNewException();
+  return p;
+ #endif
+}
 
-void __cdecl operator delete(void *p)
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw()
 {
-  if (p == 0)
+  if (!p)
     return;
+ #ifdef _WIN32
   EnterCriticalSection(&cs);
   /*
-  for (int i = 0; i < index; i++)
+  for (int i = 0; i < g_index; i++)
     if (a[i] == p)
       a[i] = 0;
   */
   HeapFree(GetProcessHeap(), 0, p);
+  if (numAllocs == 0)
+    numAllocs = numAllocs; // ERROR
   numAllocs--;
+  if (numAllocs == 0)
+    numAllocs = numAllocs; // OK: all objects were deleted
   printf("Free %d\n", numAllocs);
   LeaveCriticalSection(&cs);
+ #else
+  free(p);
+  numAllocs--;
+  printf("Free %d\n", numAllocs);
+ #endif
+}
+
+/*
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size)
+{
+  printf("operator_new[] : ");
+  return operator new(size);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t sz) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete_size : size=%d  : ", (unsigned)sz);
+  operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete[] : ");
+  operator delete(p);
+}
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p, size_t sz) throw()
+{
+  if (!p)
+    return;
+  printf("operator_delete_size[] : size=%d  : ", (unsigned)sz);
+  operator delete(p);
 }
+*/
 
 #endif
 
diff --git a/CPP/Common/NewHandler.h b/CPP/Common/NewHandler.h
index aedeca6..50f6d0a 100644
--- a/CPP/Common/NewHandler.h
+++ b/CPP/Common/NewHandler.h
@@ -1,7 +1,7 @@
 // Common/NewHandler.h
 
-#ifndef __COMMON_NEW_HANDLER_H
-#define __COMMON_NEW_HANDLER_H
+#ifndef ZIP7_INC_COMMON_NEW_HANDLER_H
+#define ZIP7_INC_COMMON_NEW_HANDLER_H
 
 /*
 NewHandler.h and NewHandler.cpp allows to solve problem with compilers that
@@ -10,6 +10,16 @@ don't throw exception in operator new().
 This file must be included before any code that uses operators new() or delete()
 and you must compile and link "NewHandler.cpp", if you use some old MSVC compiler.
 
+DOCs:
+  Since ISO C++98, operator new throws std::bad_alloc when memory allocation fails.
+  MSVC 6.0 returned a null pointer on an allocation failure.
+  Beginning in VS2002, operator new conforms to the standard and throws on failure.
+
+  By default, the compiler also generates defensive null checks to prevent
+  these older-style allocators from causing an immediate crash on failure.
+  The /Zc:throwingNew option tells the compiler to leave out these null checks,
+  on the assumption that all linked memory allocators conform to the standard.
+
 The operator new() in some MSVC versions doesn't throw exception std::bad_alloc.
 MSVC 6.0 (_MSC_VER == 1200) doesn't throw exception.
 The code produced by some another MSVC compilers also can be linked
@@ -36,13 +46,13 @@ void my_delete(void *p) throw();
 #endif
 
 
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
   // If you want to use default operator new(), you can disable the following line
-  #define _7ZIP_REDEFINE_OPERATOR_NEW
+  #define Z7_REDEFINE_OPERATOR_NEW
 #endif
 
 
-#ifdef _7ZIP_REDEFINE_OPERATOR_NEW
+#ifdef Z7_REDEFINE_OPERATOR_NEW
 
 // std::bad_alloc can require additional DLL dependency.
 // So we don't define CNewException as std::bad_alloc here.
diff --git a/CPP/Common/Random.h b/CPP/Common/Random.h
index e784e98..283869e 100644
--- a/CPP/Common/Random.h
+++ b/CPP/Common/Random.h
@@ -1,7 +1,7 @@
 // Common/Random.h
 
-#ifndef __COMMON_RANDOM_H
-#define __COMMON_RANDOM_H
+#ifndef ZIP7_INC_COMMON_RANDOM_H
+#define ZIP7_INC_COMMON_RANDOM_H
 
 class CRandom
 {
diff --git a/CPP/Common/Sha1Reg.cpp b/CPP/Common/Sha1Reg.cpp
index 0cb2baf..64eef34 100644
--- a/CPP/Common/Sha1Reg.cpp
+++ b/CPP/Common/Sha1Reg.cpp
@@ -9,13 +9,14 @@
 
 #include "../7zip/Common/RegisterCodec.h"
 
-class CSha1Hasher:
-  public IHasher,
-  public ICompressSetCoderProperties,
-  public CMyUnknownImp
-{
-  CAlignedBuffer _buf;
-  Byte mtDummy[1 << 7];
+Z7_CLASS_IMP_COM_2(
+  CSha1Hasher
+  , IHasher
+  , ICompressSetCoderProperties
+)
+  CAlignedBuffer1 _buf;
+public:
+  Byte _mtDummy[1 << 7];
   
   CSha1 *Sha() { return (CSha1 *)(void *)(Byte *)_buf; }
 public:
@@ -25,36 +26,32 @@ public:
     Sha1_SetFunction(Sha(), 0);
     Sha1_InitState(Sha());
   }
-
-  MY_UNKNOWN_IMP2(IHasher, ICompressSetCoderProperties)
-  INTERFACE_IHasher(;)
-  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
 };
 
-STDMETHODIMP_(void) CSha1Hasher::Init() throw()
+Z7_COM7F_IMF2(void, CSha1Hasher::Init())
 {
   Sha1_InitState(Sha());
 }
 
-STDMETHODIMP_(void) CSha1Hasher::Update(const void *data, UInt32 size) throw()
+Z7_COM7F_IMF2(void, CSha1Hasher::Update(const void *data, UInt32 size))
 {
   Sha1_Update(Sha(), (const Byte *)data, size);
 }
 
-STDMETHODIMP_(void) CSha1Hasher::Final(Byte *digest) throw()
+Z7_COM7F_IMF2(void, CSha1Hasher::Final(Byte *digest))
 {
   Sha1_Final(Sha(), digest);
 }
 
 
-STDMETHODIMP CSha1Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
+Z7_COM7F_IMF(CSha1Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
 {
   unsigned algo = 0;
   for (UInt32 i = 0; i < numProps; i++)
   {
-    const PROPVARIANT &prop = coderProps[i];
     if (propIDs[i] == NCoderPropID::kDefaultProp)
     {
+      const PROPVARIANT &prop = coderProps[i];
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
       if (prop.ulVal > 2)
diff --git a/CPP/Common/Sha256Reg.cpp b/CPP/Common/Sha256Reg.cpp
index 5f3a35b..b5689c4 100644
--- a/CPP/Common/Sha256Reg.cpp
+++ b/CPP/Common/Sha256Reg.cpp
@@ -9,13 +9,14 @@
 
 #include "../7zip/Common/RegisterCodec.h"
 
-class CSha256Hasher:
-  public IHasher,
-  public ICompressSetCoderProperties,
-  public CMyUnknownImp
-{
-  CAlignedBuffer _buf;
-  Byte mtDummy[1 << 7];
+Z7_CLASS_IMP_COM_2(
+  CSha256Hasher
+  , IHasher
+  , ICompressSetCoderProperties
+)
+  CAlignedBuffer1 _buf;
+public:
+  Byte _mtDummy[1 << 7];
 
   CSha256 *Sha() { return (CSha256 *)(void *)(Byte *)_buf; }
 public:
@@ -25,36 +26,32 @@ public:
     Sha256_SetFunction(Sha(), 0);
     Sha256_InitState(Sha());
   }
-
-  MY_UNKNOWN_IMP2(IHasher, ICompressSetCoderProperties)
-  INTERFACE_IHasher(;)
-  STDMETHOD(SetCoderProperties)(const PROPID *propIDs, const PROPVARIANT *props, UInt32 numProps);
 };
 
-STDMETHODIMP_(void) CSha256Hasher::Init() throw()
+Z7_COM7F_IMF2(void, CSha256Hasher::Init())
 {
   Sha256_InitState(Sha());
 }
 
-STDMETHODIMP_(void) CSha256Hasher::Update(const void *data, UInt32 size) throw()
+Z7_COM7F_IMF2(void, CSha256Hasher::Update(const void *data, UInt32 size))
 {
   Sha256_Update(Sha(), (const Byte *)data, size);
 }
 
-STDMETHODIMP_(void) CSha256Hasher::Final(Byte *digest) throw()
+Z7_COM7F_IMF2(void, CSha256Hasher::Final(Byte *digest))
 {
   Sha256_Final(Sha(), digest);
 }
 
 
-STDMETHODIMP CSha256Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps)
+Z7_COM7F_IMF(CSha256Hasher::SetCoderProperties(const PROPID *propIDs, const PROPVARIANT *coderProps, UInt32 numProps))
 {
   unsigned algo = 0;
   for (UInt32 i = 0; i < numProps; i++)
   {
-    const PROPVARIANT &prop = coderProps[i];
     if (propIDs[i] == NCoderPropID::kDefaultProp)
     {
+      const PROPVARIANT &prop = coderProps[i];
       if (prop.vt != VT_UI4)
         return E_INVALIDARG;
       if (prop.ulVal > 2)
diff --git a/CPP/Common/StdAfx.h b/CPP/Common/StdAfx.h
index 420f5c3..a5228b0 100644
--- a/CPP/Common/StdAfx.h
+++ b/CPP/Common/StdAfx.h
@@ -1,7 +1,7 @@
 // StdAfx.h
 
-#ifndef __STDAFX_H
-#define __STDAFX_H
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
 
 #include "Common.h"
 
diff --git a/CPP/Common/StdInStream.cpp b/CPP/Common/StdInStream.cpp
index abad34b..7b209f1 100644
--- a/CPP/Common/StdInStream.cpp
+++ b/CPP/Common/StdInStream.cpp
@@ -14,10 +14,12 @@
 // #define kReadErrorMessage "Error reading input stream"
 // #define kIllegalCharMessage "Illegal zero character in input stream"
 
-#define kFileOpenMode TEXT("r")
 
 CStdInStream g_StdIn(stdin);
 
+/*
+#define kFileOpenMode TEXT("r")
+
 bool CStdInStream::Open(LPCTSTR fileName) throw()
 {
   Close();
@@ -39,6 +41,7 @@ bool CStdInStream::Close() throw()
   _streamIsOpen = (fclose(_stream) != 0);
   return !_streamIsOpen;
 }
+*/
 
 bool CStdInStream::ScanAStringUntilNewLine(AString &s)
 {
diff --git a/CPP/Common/StdInStream.h b/CPP/Common/StdInStream.h
index 71578eb..81ca3bf 100644
--- a/CPP/Common/StdInStream.h
+++ b/CPP/Common/StdInStream.h
@@ -1,7 +1,7 @@
 // Common/StdInStream.h
 
-#ifndef __COMMON_STD_IN_STREAM_H
-#define __COMMON_STD_IN_STREAM_H
+#ifndef ZIP7_INC_COMMON_STD_IN_STREAM_H
+#define ZIP7_INC_COMMON_STD_IN_STREAM_H
 
 #include <stdio.h>
 
@@ -11,20 +11,22 @@
 class CStdInStream
 {
   FILE *_stream;
-  bool _streamIsOpen;
+  // bool _streamIsOpen;
 public:
   int CodePage;
 
   CStdInStream(FILE *stream = NULL):
       _stream(stream),
-      _streamIsOpen(false),
+      // _streamIsOpen(false),
       CodePage(-1)
-      {};
+      {}
 
+  /*
   ~CStdInStream() { Close(); }
 
   bool Open(LPCTSTR fileName) throw();
   bool Close() throw();
+  */
 
   // returns:
   //   false, if ZERO character in stream
diff --git a/CPP/Common/StdOutStream.cpp b/CPP/Common/StdOutStream.cpp
index 40799e2..cfa5fde 100644
--- a/CPP/Common/StdOutStream.cpp
+++ b/CPP/Common/StdOutStream.cpp
@@ -11,11 +11,12 @@
 #include "StringConvert.h"
 #include "UTFConvert.h"
 
-#define kFileOpenMode "wt"
-
 CStdOutStream g_StdOut(stdout);
 CStdOutStream g_StdErr(stderr);
 
+/*
+// #define kFileOpenMode "wt"
+
 bool CStdOutStream::Open(const char *fileName) throw()
 {
   Close();
@@ -34,6 +35,7 @@ bool CStdOutStream::Close() throw()
   _streamIsOpen = false;
   return true;
 }
+*/
 
 bool CStdOutStream::Flush() throw()
 {
@@ -73,7 +75,7 @@ void CStdOutStream::Convert_UString_to_AString(const UString &src, AString &dest
 
 static const wchar_t kReplaceChar = '_';
 
-void CStdOutStream::Normalize_UString__LF_Allowed(UString &s)
+void CStdOutStream::Normalize_UString_LF_Allowed(UString &s)
 {
   unsigned len = s.Len();
   wchar_t *d = s.GetBuf();
diff --git a/CPP/Common/StdOutStream.h b/CPP/Common/StdOutStream.h
index 93f1dfa..bd15d7c 100644
--- a/CPP/Common/StdOutStream.h
+++ b/CPP/Common/StdOutStream.h
@@ -1,7 +1,7 @@
 // Common/StdOutStream.h
 
-#ifndef __COMMON_STD_OUT_STREAM_H
-#define __COMMON_STD_OUT_STREAM_H
+#ifndef ZIP7_INC_COMMON_STD_OUT_STREAM_H
+#define ZIP7_INC_COMMON_STD_OUT_STREAM_H
 
 #include <stdio.h>
 
@@ -11,26 +11,28 @@
 class CStdOutStream
 {
   FILE *_stream;
-  bool _streamIsOpen;
+  // bool _streamIsOpen;
 public:
   bool IsTerminalMode;
   int CodePage;
 
-  CStdOutStream(FILE *stream = 0):
+  CStdOutStream(FILE *stream = NULL):
       _stream(stream),
-      _streamIsOpen(false),
+      // _streamIsOpen(false),
       IsTerminalMode(false),
       CodePage(-1)
-      {};
+      {}
 
-  ~CStdOutStream() { Close(); }
+  // ~CStdOutStream() { Close(); }
 
   // void AttachStdStream(FILE *stream) { _stream  = stream; _streamIsOpen = false; }
   // bool IsDefined() const { return _stream  != NULL; }
 
   operator FILE *() { return _stream; }
+  /*
   bool Open(const char *fileName) throw();
   bool Close() throw();
+  */
   bool Flush() throw();
   
   CStdOutStream & operator<<(CStdOutStream & (* func)(CStdOutStream  &))
@@ -60,7 +62,7 @@ public:
   void PrintUString(const UString &s, AString &temp);
   void Convert_UString_to_AString(const UString &src, AString &dest);
 
-  void Normalize_UString__LF_Allowed(UString &s);
+  void Normalize_UString_LF_Allowed(UString &s);
   void Normalize_UString(UString &s);
 
   void NormalizePrint_UString(const UString &s, UString &tempU, AString &tempA);
diff --git a/CPP/Common/StringConvert.cpp b/CPP/Common/StringConvert.cpp
index c0bde0f..f25396a 100644
--- a/CPP/Common/StringConvert.cpp
+++ b/CPP/Common/StringConvert.cpp
@@ -534,6 +534,7 @@ AString UnicodeStringToMultiByte(const UString &src, UINT codePage)
 
 
 
+#if !defined(_WIN32) || defined(ENV_HAVE_LOCALE)
 
 #ifdef _WIN32
 #define U_to_A(a, b, c)  UnicodeStringToMultiByte2
@@ -544,8 +545,6 @@ AString UnicodeStringToMultiByte(const UString &src, UINT codePage)
 // #define A_to_U(a, b, c)  MultiByteToUnicodeString2_Native(a, b)
 #endif
 
-#if !defined(_WIN32) || defined(ENV_HAVE_LOCALE)
-
 bool IsNativeUTF8()
 {
   UString u;
diff --git a/CPP/Common/StringConvert.h b/CPP/Common/StringConvert.h
index 865c025..2092a2d 100644
--- a/CPP/Common/StringConvert.h
+++ b/CPP/Common/StringConvert.h
@@ -1,7 +1,7 @@
 // Common/StringConvert.h
 
-#ifndef __COMMON_STRING_CONVERT_H
-#define __COMMON_STRING_CONVERT_H
+#ifndef ZIP7_INC_COMMON_STRING_CONVERT_H
+#define ZIP7_INC_COMMON_STRING_CONVERT_H
 
 #include "MyString.h"
 #include "MyWindows.h"
diff --git a/CPP/Common/StringToInt.h b/CPP/Common/StringToInt.h
index 4057e49..c9dce7d 100644
--- a/CPP/Common/StringToInt.h
+++ b/CPP/Common/StringToInt.h
@@ -1,7 +1,7 @@
 // Common/StringToInt.h
 
-#ifndef __COMMON_STRING_TO_INT_H
-#define __COMMON_STRING_TO_INT_H
+#ifndef ZIP7_INC_COMMON_STRING_TO_INT_H
+#define ZIP7_INC_COMMON_STRING_TO_INT_H
 
 #include "MyTypes.h"
 
diff --git a/CPP/Common/TextConfig.cpp b/CPP/Common/TextConfig.cpp
index 1428aab..d3e561c 100644
--- a/CPP/Common/TextConfig.cpp
+++ b/CPP/Common/TextConfig.cpp
@@ -15,7 +15,7 @@ static AString GetIDString(const char *s, unsigned &finishPos)
   AString result;
   for (finishPos = 0; ; finishPos++)
   {
-    char c = s[finishPos];
+    const char c = s[finishPos];
     if (IsDelimitChar(c) || c == '=')
       break;
     result += c;
@@ -35,7 +35,7 @@ static bool SkipSpaces(const AString &s, unsigned &pos)
 {
   for (; pos < s.Len(); pos++)
   {
-    char c = s[pos];
+    const char c = s[pos];
     if (!IsDelimitChar(c))
     {
       if (c != ';')
@@ -111,13 +111,13 @@ int FindTextConfigItem(const CObjectVector<CTextConfigPair> &pairs, const char *
 {
   FOR_VECTOR (i, pairs)
     if (pairs[i].ID.IsEqualTo(id))
-      return i;
+      return (int)i;
   return -1;
 }
 
 UString GetTextConfigValue(const CObjectVector<CTextConfigPair> &pairs, const char *id)
 {
-  int index = FindTextConfigItem(pairs, id);
+  const int index = FindTextConfigItem(pairs, id);
   if (index < 0)
     return UString();
   return pairs[index].String;
diff --git a/CPP/Common/TextConfig.h b/CPP/Common/TextConfig.h
index cc7ce41..2263a44 100644
--- a/CPP/Common/TextConfig.h
+++ b/CPP/Common/TextConfig.h
@@ -1,7 +1,7 @@
 // Common/TextConfig.h
 
-#ifndef __COMMON_TEXT_CONFIG_H
-#define __COMMON_TEXT_CONFIG_H
+#ifndef ZIP7_INC_COMMON_TEXT_CONFIG_H
+#define ZIP7_INC_COMMON_TEXT_CONFIG_H
 
 #include "MyString.h"
 
diff --git a/CPP/Common/UTFConvert.cpp b/CPP/Common/UTFConvert.cpp
index ac069db..fb166b7 100644
--- a/CPP/Common/UTFConvert.cpp
+++ b/CPP/Common/UTFConvert.cpp
@@ -8,17 +8,17 @@
 #include "UTFConvert.h"
 
 
-#ifndef _WCHART_IS_16BIT
+#ifndef Z7_WCHART_IS_16BIT
 #ifndef __APPLE__
   // we define it if the system supports files with non-utf8 symbols:
-  #define _UTF8_RAW_NON_UTF8_SUPPORTED
+  #define MY_UTF8_RAW_NON_UTF8_SUPPORTED
 #endif
 #endif
 
 /*
-  _UTF8_START(n) - is a base value for start byte (head), if there are (n) additional bytes after start byte
+  MY_UTF8_START(n) - is a base value for start byte (head), if there are (n) additional bytes after start byte
   
-  n : _UTF8_START(n) : Bits of code point
+  n : MY_UTF8_START(n) : Bits of code point
 
   0 : 0x80 :    : unused
   1 : 0xC0 : 11 :
@@ -30,13 +30,13 @@
   7 : 0xFF :
 */
 
-#define _UTF8_START(n) (0x100 - (1 << (7 - (n))))
+#define MY_UTF8_START(n) (0x100 - (1 << (7 - (n))))
 
-#define _UTF8_HEAD_PARSE2(n) \
-    if (c < _UTF8_START((n) + 1)) \
-    { numBytes = (n); val -= _UTF8_START(n); }
+#define MY_UTF8_HEAD_PARSE2(n) \
+    if (c < MY_UTF8_START((n) + 1)) \
+    { numBytes = (n); val -= MY_UTF8_START(n); }
 
-#ifndef _WCHART_IS_16BIT
+#ifndef Z7_WCHART_IS_16BIT
 
 /*
    if (wchar_t is 32-bit), we can support large points in long UTF-8 sequence,
@@ -46,30 +46,30 @@
      (_UTF8_NUM_TAIL_BYTES_MAX == 6) : (36-bit hack)
 */
 
-#define _UTF8_NUM_TAIL_BYTES_MAX 5
+#define MY_UTF8_NUM_TAIL_BYTES_MAX 5
 #endif
 
 /*
-#define _UTF8_HEAD_PARSE \
+#define MY_UTF8_HEAD_PARSE \
     UInt32 val = c; \
-         _UTF8_HEAD_PARSE2(1) \
-    else _UTF8_HEAD_PARSE2(2) \
-    else _UTF8_HEAD_PARSE2(3) \
-    else _UTF8_HEAD_PARSE2(4) \
-    else _UTF8_HEAD_PARSE2(5) \
-  #if _UTF8_NUM_TAIL_BYTES_MAX >= 6
-    else _UTF8_HEAD_PARSE2(6)
+         MY_UTF8_HEAD_PARSE2(1) \
+    else MY_UTF8_HEAD_PARSE2(2) \
+    else MY_UTF8_HEAD_PARSE2(3) \
+    else MY_UTF8_HEAD_PARSE2(4) \
+    else MY_UTF8_HEAD_PARSE2(5) \
+  #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
+    else MY_UTF8_HEAD_PARSE2(6)
   #endif
 */
 
-#define _UTF8_HEAD_PARSE_MAX_3_BYTES \
+#define MY_UTF8_HEAD_PARSE_MAX_3_BYTES \
     UInt32 val = c; \
-         _UTF8_HEAD_PARSE2(1) \
-    else _UTF8_HEAD_PARSE2(2) \
-    else { numBytes = 3; val -= _UTF8_START(3); }
+         MY_UTF8_HEAD_PARSE2(1) \
+    else MY_UTF8_HEAD_PARSE2(2) \
+    else { numBytes = 3; val -= MY_UTF8_START(3); }
 
 
-#define _UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
+#define MY_UTF8_RANGE(n) (((UInt32)1) << ((n) * 5 + 6))
 
 
 #define START_POINT_FOR_SURROGATE 0x10000
@@ -82,7 +82,7 @@
 */
  
 
-#if defined(_WCHART_IS_16BIT)
+#if defined(Z7_WCHART_IS_16BIT)
 
 #define UTF_ESCAPE_PLANE 0
 
@@ -102,7 +102,7 @@ we can place 128 ESCAPE chars to
 #define UTF_ESCAPE_PLANE 0
 
 /*
-  if (UTF_FLAG__FROM_UTF8__USE_ESCAPE is set)
+  if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is set)
   {
     if (UTF_ESCAPE_PLANE is UTF_ESCAPE_PLANE_HIGH)
     {
@@ -111,13 +111,13 @@ we can place 128 ESCAPE chars to
       So we still need a way to extract 8-bit Escapes and BMP-Escapes-8
       from same BMP-Escapes-16 stored in 7z.
       And if we want to restore any 8-bit from 7z archive,
-      we still must use UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT for (utf-8 -> utf-16)
+      we still must use Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT for (utf-8 -> utf-16)
       Also we need additional Conversions to tranform from utf-16 to utf-16-With-Escapes-21
     }
     else (UTF_ESCAPE_PLANE == 0)
     {
       we must convert original 3-bytes utf-8 BMP-Escape point to sequence
-      of 3 BMP-Escape-16 points with UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT
+      of 3 BMP-Escape-16 points with Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
       so we can extract original RAW-UTF-8 from UTFD-16 later.
     }
   }
@@ -138,7 +138,7 @@ we can place 128 ESCAPE chars to
 #define IS_LOW_SURROGATE_POINT(v) (((v) & (UInt32)0xfffffC00) == 0xdc00)
 
 
-#define _ERROR_UTF8_CHECK \
+#define UTF_ERROR_UTF8_CHECK \
   { NonUtf = true; continue; }
 
 void CUtf8Check::Check_Buf(const char *src, size_t size) throw()
@@ -168,19 +168,19 @@ void CUtf8Check::Check_Buf(const char *src, size_t size) throw()
     if (c < 0x80)
       continue;
     
-    if (c < 0xc0 + 2)// it's limit for 0x140000 unicode codes : win32 compatibility
-      _ERROR_UTF8_CHECK
+    if (c < 0xc0 + 2) // it's limit for 0x140000 unicode codes : win32 compatibility
+      UTF_ERROR_UTF8_CHECK
 
     unsigned numBytes;
 
     UInt32 val = c;
-         _UTF8_HEAD_PARSE2(1)
-    else _UTF8_HEAD_PARSE2(2)
-    else _UTF8_HEAD_PARSE2(4)
-    else _UTF8_HEAD_PARSE2(5)
+         MY_UTF8_HEAD_PARSE2(1)
+    else MY_UTF8_HEAD_PARSE2(2)
+    else MY_UTF8_HEAD_PARSE2(4)
+    else MY_UTF8_HEAD_PARSE2(5)
     else
     {
-      _ERROR_UTF8_CHECK
+      UTF_ERROR_UTF8_CHECK
     }
 
     unsigned pos = 0;
@@ -206,7 +206,7 @@ void CUtf8Check::Check_Buf(const char *src, size_t size) throw()
       if (pos == size)
         Truncated = true;
       else
-        _ERROR_UTF8_CHECK
+        UTF_ERROR_UTF8_CHECK
     }
 
     #ifdef UTF_ESCAPE_BASE
@@ -268,7 +268,7 @@ bool CheckUTF8(const char *src, bool allowReduced) throw()
       return false;
     
     unsigned numBytes;
-    _UTF8_HEAD_PARSE
+    MY_UTF8_HEAD_PARSE
     else
       return false;
 
@@ -285,7 +285,7 @@ bool CheckUTF8(const char *src, bool allowReduced) throw()
     }
     while (--numBytes);
 
-    if (val < _UTF8_RANGE(pos - 1))
+    if (val < MY_UTF8_RANGE(pos - 1))
       return false;
 
     if (val >= 0x110000)
@@ -303,18 +303,18 @@ bool CheckUTF8(const char *src, bool allowReduced) throw()
 
 
 #define UTF_ESCAPE(c) \
-   ((flags & UTF_FLAG__FROM_UTF8__USE_ESCAPE) ? \
+   ((flags & Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE) ? \
     UTF_ESCAPE_PLANE + UTF_ESCAPE_BASE + (c) : UTF_REPLACEMENT_CHAR)
 
 /*
-#define _HARD_ERROR_UTF8
+#define UTF_HARD_ERROR_UTF8
   { if (dest) dest[destPos] = (wchar_t)UTF_ESCAPE(c); \
     destPos++; ok = false; continue; }
 */
 
 // we ignore utf errors, and don't change (ok) variable!
 
-#define _ERROR_UTF8 \
+#define UTF_ERROR_UTF8 \
   { if (dest) dest[destPos] = (wchar_t)UTF_ESCAPE(c); \
     destPos++; continue; }
 
@@ -362,12 +362,12 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
     if (c < 0xc0 + 2
       || c >= 0xf5) // it's limit for 0x140000 unicode codes : win32 compatibility
     {
-      _ERROR_UTF8
+      UTF_ERROR_UTF8
     }
 
     unsigned numBytes;
 
-    _UTF8_HEAD_PARSE_MAX_3_BYTES
+    MY_UTF8_HEAD_PARSE_MAX_3_BYTES
 
     unsigned pos = 0;
     do
@@ -387,7 +387,7 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
           break;
         if (numBytes == 2)
         {
-          if (flags & UTF_FLAG__FROM_UTF8__SURROGATE_ERROR)
+          if (flags & Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR)
             if ((val & (0xF800 >> 6)) == (0xd800 >> 6))
               break;
         }
@@ -399,27 +399,27 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
 
     if (numBytes != 0)
     {
-      if ((flags & UTF_FLAG__FROM_UTF8__USE_ESCAPE) == 0)
+      if ((flags & Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE) == 0)
       {
         // the following code to emit the 0xfffd chars as win32 Utf8 function.
         // disable the folling line, if you need 0xfffd for each incorrect byte as in Escape mode
         src += pos;
       }
-      _ERROR_UTF8
+      UTF_ERROR_UTF8
     }
 
     /*
-    if (val < _UTF8_RANGE(pos - 1))
-      _ERROR_UTF8
+    if (val < MY_UTF8_RANGE(pos - 1))
+      UTF_ERROR_UTF8
     */
 
     #ifdef UTF_ESCAPE_BASE
     
-      if ((flags & UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT)
+      if ((flags & Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT)
           && IS_ESCAPE_POINT(val, 0))
       {
         // We will emit 3 utf16-Escape-16-21 points from one Escape-16 point (3 bytes)
-        _ERROR_UTF8
+        UTF_ERROR_UTF8
       }
     
     #endif
@@ -434,11 +434,11 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
     if (val < START_POINT_FOR_SURROGATE)
     {
       /*
-      if ((flags & UTF_FLAG__FROM_UTF8__SURROGATE_ERROR)
+      if ((flags & Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR)
           && IS_SURROGATE_POINT(val))
       {
         // We will emit 3 utf16-Escape-16-21 points from one Surrogate-16 point (3 bytes)
-        _ERROR_UTF8
+        UTF_ERROR_UTF8
       }
       */
       if (dest)
@@ -451,7 +451,7 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
       if (val >= 0x110000)
       {
         // We will emit utf16-Escape-16-21 point from each source byte
-        _ERROR_UTF8
+        UTF_ERROR_UTF8
       }
       */
       if (dest)
@@ -467,8 +467,8 @@ static bool Utf8_To_Utf16(wchar_t *dest, size_t *destLen, const char *src, const
 
 
 
-#define _UTF8_HEAD(n, val) ((char)(_UTF8_START(n) + (val >> (6 * (n)))))
-#define _UTF8_CHAR(n, val) ((char)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
+#define MY_UTF8_HEAD(n, val) ((char)(MY_UTF8_START(n) + (val >> (6 * (n)))))
+#define MY_UTF8_CHAR(n, val) ((char)(0x80 + (((val) >> (6 * (n))) & 0x3F)))
 
 static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim, unsigned flags)
 {
@@ -483,7 +483,7 @@ static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim, unsi
     if (val < 0x80)
       continue;
 
-    if (val < _UTF8_RANGE(1))
+    if (val < MY_UTF8_RANGE(1))
     {
       size++;
       continue;
@@ -492,12 +492,12 @@ static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim, unsi
     #ifdef UTF_ESCAPE_BASE
     
     #if UTF_ESCAPE_PLANE != 0
-    if (flags & UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE)
+    if (flags & Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE)
       if (IS_ESCAPE_POINT(val, UTF_ESCAPE_PLANE))
         continue;
     #endif
     
-    if (flags & UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE)
+    if (flags & Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE)
       if (IS_ESCAPE_POINT(val, 0))
         continue;
     
@@ -517,18 +517,18 @@ static size_t Utf16_To_Utf8_Calc(const wchar_t *src, const wchar_t *srcLim, unsi
       continue;
     }
 
-    #ifdef _WCHART_IS_16BIT
+    #ifdef Z7_WCHART_IS_16BIT
     
     size += 2;
     
     #else
 
-         if (val < _UTF8_RANGE(2)) size += 2;
-    else if (val < _UTF8_RANGE(3)) size += 3;
-    else if (val < _UTF8_RANGE(4)) size += 4;
-    else if (val < _UTF8_RANGE(5)) size += 5;
+         if (val < MY_UTF8_RANGE(2)) size += 2;
+    else if (val < MY_UTF8_RANGE(3)) size += 3;
+    else if (val < MY_UTF8_RANGE(4)) size += 4;
+    else if (val < MY_UTF8_RANGE(5)) size += 5;
     else
-    #if _UTF8_NUM_TAIL_BYTES_MAX >= 6
+    #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
       size += 6;
     #else
       size += 3;
@@ -554,10 +554,10 @@ static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim
       continue;
     }
 
-    if (val < _UTF8_RANGE(1))
+    if (val < MY_UTF8_RANGE(1))
     {
-      dest[0] = _UTF8_HEAD(1, val);
-      dest[1] = _UTF8_CHAR(0, val);
+      dest[0] = MY_UTF8_HEAD(1, val);
+      dest[1] = MY_UTF8_CHAR(0, val);
       dest += 2;
       continue;
     }
@@ -567,11 +567,11 @@ static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim
     #if UTF_ESCAPE_PLANE != 0
     /*
        if (wchar_t is 32-bit)
-            && (UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE is set)
+            && (Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE is set)
             && (point is virtual escape plane)
           we extract 8-bit byte from virtual HIGH-ESCAPE PLANE.
     */
-    if (flags & UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE)
+    if (flags & Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE)
       if (IS_ESCAPE_POINT(val, UTF_ESCAPE_PLANE))
       {
         *dest++ = (char)(val);
@@ -579,10 +579,10 @@ static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim
       }
     #endif // UTF_ESCAPE_PLANE != 0
 
-    /* if (UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE is defined)
+    /* if (Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE is defined)
           we extract 8-bit byte from BMP-ESCAPE PLANE. */
 
-    if (flags & UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE)
+    if (flags & Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE)
       if (IS_ESCAPE_POINT(val, 0))
       {
         *dest++ = (char)(val);
@@ -601,46 +601,46 @@ static char *Utf16_To_Utf8(char *dest, const wchar_t *src, const wchar_t *srcLim
         {
           src++;
           val = (((val - 0xd800) << 10) | (c2 - 0xdc00)) + 0x10000;
-          dest[0] = _UTF8_HEAD(3, val);
-          dest[1] = _UTF8_CHAR(2, val);
-          dest[2] = _UTF8_CHAR(1, val);
-          dest[3] = _UTF8_CHAR(0, val);
+          dest[0] = MY_UTF8_HEAD(3, val);
+          dest[1] = MY_UTF8_CHAR(2, val);
+          dest[2] = MY_UTF8_CHAR(1, val);
+          dest[3] = MY_UTF8_CHAR(0, val);
           dest += 4;
           continue;
         }
       }
-      if (flags & UTF_FLAG__TO_UTF8__SURROGATE_ERROR)
+      if (flags & Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR)
         val = UTF_REPLACEMENT_CHAR; // WIN32 function does it
     }
 
-    #ifndef _WCHART_IS_16BIT
-    if (val < _UTF8_RANGE(2))
+    #ifndef Z7_WCHART_IS_16BIT
+    if (val < MY_UTF8_RANGE(2))
     #endif
     {
-      dest[0] = _UTF8_HEAD(2, val);
-      dest[1] = _UTF8_CHAR(1, val);
-      dest[2] = _UTF8_CHAR(0, val);
+      dest[0] = MY_UTF8_HEAD(2, val);
+      dest[1] = MY_UTF8_CHAR(1, val);
+      dest[2] = MY_UTF8_CHAR(0, val);
       dest += 3;
       continue;
     }
     
-    #ifndef _WCHART_IS_16BIT
+    #ifndef Z7_WCHART_IS_16BIT
 
     // we don't expect this case. so we can throw exception
     // throw 20210407;
    
     char b;
     unsigned numBits;
-         if (val < _UTF8_RANGE(3)) { numBits = 6 * 3; b = _UTF8_HEAD(3, val); }
-    else if (val < _UTF8_RANGE(4)) { numBits = 6 * 4; b = _UTF8_HEAD(4, val); }
-    else if (val < _UTF8_RANGE(5)) { numBits = 6 * 5; b = _UTF8_HEAD(5, val); }
-    #if _UTF8_NUM_TAIL_BYTES_MAX >= 6
-    else                           { numBits = 6 * 6; b = (char)_UTF8_START(6); }
+         if (val < MY_UTF8_RANGE(3)) { numBits = 6 * 3; b = MY_UTF8_HEAD(3, val); }
+    else if (val < MY_UTF8_RANGE(4)) { numBits = 6 * 4; b = MY_UTF8_HEAD(4, val); }
+    else if (val < MY_UTF8_RANGE(5)) { numBits = 6 * 5; b = MY_UTF8_HEAD(5, val); }
+    #if MY_UTF8_NUM_TAIL_BYTES_MAX >= 6
+    else                           { numBits = 6 * 6; b = (char)MY_UTF8_START(6); }
     #else
     else
     {
       val = UTF_REPLACEMENT_CHAR;
-                                   { numBits = 6 * 3; b = _UTF8_HEAD(3, val); }
+                                   { numBits = 6 * 3; b = MY_UTF8_HEAD(3, val); }
     }
     #endif
 
@@ -675,11 +675,11 @@ bool ConvertUTF8ToUnicode_Flags(const AString &src, UString &dest, unsigned flag
 
 static
 unsigned g_UTF8_To_Unicode_Flags =
-    UTF_FLAG__FROM_UTF8__USE_ESCAPE
-  #ifndef _WCHART_IS_16BIT
-    | UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
-  #ifdef _UTF8_RAW_NON_UTF8_SUPPORTED
-    | UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT
+    Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+  #ifndef Z7_WCHART_IS_16BIT
+    | Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+  #ifdef MY_UTF8_RAW_NON_UTF8_SUPPORTED
+    | Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
   #endif
   #endif
     ;
@@ -729,13 +729,13 @@ void ConvertUnicodeToUTF8_Flags(const UString &src, AString &dest, unsigned flag
 
 
 unsigned g_Unicode_To_UTF8_Flags =
-      // UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE
+      // Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE
       0
   #ifndef _WIN32
-    #ifdef _UTF8_RAW_NON_UTF8_SUPPORTED
-      | UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE
+    #ifdef MY_UTF8_RAW_NON_UTF8_SUPPORTED
+      | Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE
     #else
-      | UTF_FLAG__TO_UTF8__SURROGATE_ERROR;
+      | Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
     #endif
   #endif
     ;
@@ -840,7 +840,7 @@ bool Unicode_IsThere_Utf16SurrogateError(const UString &src)
 }
 */
 
-#ifndef _WCHART_IS_16BIT
+#ifndef Z7_WCHART_IS_16BIT
 
 void Convert_UnicodeEsc16_To_UnicodeEscHigh
 #if UTF_ESCAPE_PLANE == 0
diff --git a/CPP/Common/UTFConvert.h b/CPP/Common/UTFConvert.h
index 37c4975..94a8024 100644
--- a/CPP/Common/UTFConvert.h
+++ b/CPP/Common/UTFConvert.h
@@ -1,7 +1,7 @@
 // Common/UTFConvert.h
 
-#ifndef __COMMON_UTF_CONVERT_H
-#define __COMMON_UTF_CONVERT_H
+#ifndef ZIP7_INC_COMMON_UTF_CONVERT_H
+#define ZIP7_INC_COMMON_UTF_CONVERT_H
 
 #include "MyBuffer.h"
 #include "MyString.h"
@@ -88,12 +88,12 @@ if (allowReduced == true)  - it allows truncated last character-Utf8-sequence
 bool Check_UTF8_Buf(const char *src, size_t size, bool allowReduced) throw();
 bool CheckUTF8_AString(const AString &s) throw();
 
-#define UTF_FLAG__FROM_UTF8__SURROGATE_ERROR    (1 << 0)
-#define UTF_FLAG__FROM_UTF8__USE_ESCAPE         (1 << 1)
-#define UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT (1 << 2)
+#define Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR    (1 << 0)
+#define Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE         (1 << 1)
+#define Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT (1 << 2)
 
 /*
-UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
+Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
 
    if (flag is NOT set)
    {
@@ -108,14 +108,14 @@ UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
    
    if (flag is set)
    {
-     if (UTF_FLAG__FROM_UTF8__USE_ESCAPE is defined)
+     if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is defined)
         it generates ESCAPE for SINGLE-SURROGATE-8,
-     if (UTF_FLAG__FROM_UTF8__USE_ESCAPE is not defined)
+     if (Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE is not defined)
         it generates U+fffd for SINGLE-SURROGATE-8,
    }
 
 
-UTF_FLAG__FROM_UTF8__USE_ESCAPE
+Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
 
    if (flag is NOT set)
      it generates (U+fffd) code for non-UTF-8 (invalid) characters
@@ -126,7 +126,7 @@ UTF_FLAG__FROM_UTF8__USE_ESCAPE
      And later we can restore original UTF-8-RAW characters from (ESCAPE-16-21) codes.
    }
 
-UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT
+Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
 
    if (flag is NOT set)
    {
@@ -146,9 +146,9 @@ Main USE CASES with UTF-8 <-> UTF-16 conversions:
 
  WIN32:   UTF-16-RAW -> UTF-8 (Archive) -> UTF-16-RAW
    {
-            set UTF_FLAG__FROM_UTF8__USE_ESCAPE
-     Do NOT set UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
-     Do NOT set UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT
+            set Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+     Do NOT set Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+     Do NOT set Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
      
      So we restore original SINGLE-SURROGATE-16 from single SINGLE-SURROGATE-8.
    }
@@ -157,17 +157,17 @@ Main USE CASES with UTF-8 <-> UTF-16 conversions:
    {
      we want restore original UTF-8-RAW sequence later from that ESCAPE-16.
      Set the flags:
-       UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
-       UTF_FLAG__FROM_UTF8__USE_ESCAPE
-       UTF_FLAG__FROM_UTF8__BMP_ESCAPE_CONVERT
+       Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+       Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
+       Z7_UTF_FLAG_FROM_UTF8_BMP_ESCAPE_CONVERT
    }
 
  MacOS:   UTF-8-RAW -> UTF-16 (Intermediate / Archive) -> UTF-8-RAW
    {
      we want to restore correct UTF-8 without any BMP processing:
      Set the flags:
-       UTF_FLAG__FROM_UTF8__SURROGATE_ERROR
-       UTF_FLAG__FROM_UTF8__USE_ESCAPE
+       Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR
+       Z7_UTF_FLAG_FROM_UTF8_USE_ESCAPE
    }
 
 */
@@ -178,12 +178,12 @@ bool Convert_UTF8_Buf_To_Unicode(const char *src, size_t srcSize, UString &dest,
 bool ConvertUTF8ToUnicode_Flags(const AString &src, UString &dest, unsigned flags = 0);
 bool ConvertUTF8ToUnicode(const AString &src, UString &dest);
 
-#define UTF_FLAG__TO_UTF8__SURROGATE_ERROR    (1 << 8)
-#define UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE (1 << 9)
-// #define UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE  (1 << 10)
+#define Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR    (1 << 8)
+#define Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE (1 << 9)
+// #define Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE  (1 << 10)
 
 /*
-UTF_FLAG__TO_UTF8__SURROGATE_ERROR
+Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
 
   if (flag is NOT set)
   {
@@ -193,7 +193,7 @@ UTF_FLAG__TO_UTF8__SURROGATE_ERROR
      
      In Linux :
        use-case-1: UTF-8 -> UTF-16 -> UTF-8  doesn't generate UTF-16 SINGLE-SURROGATE,
-                   if (UTF_FLAG__FROM_UTF8__SURROGATE_ERROR) is used.
+                   if (Z7_UTF_FLAG_FROM_UTF8_SURROGATE_ERROR) is used.
        use-case 2: UTF-16-7z (with SINGLE-SURROGATE from Windows) -> UTF-8 (Linux)
                    will generate SINGLE-SURROGATE-UTF-8 here.
   }
@@ -206,17 +206,17 @@ UTF_FLAG__TO_UTF8__SURROGATE_ERROR
   }
 
 
-UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE
+Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE
   
   if (flag is NOT set) it doesn't extract  raw 8-bit symbol from Escape-Plane-16
   if (flag is set)     it         extracts raw 8-bit symbol from Escape-Plane-16
 
   in Linux we need some way to extract NON-UTF8 RAW 8-bits from BMP (UTF-16 7z archive):
   if (we       use High-Escape-Plane), we can transfer BMP escapes to High-Escape-Plane.
-  if (we don't use High-Escape-Plane), we must use UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE.
+  if (we don't use High-Escape-Plane), we must use Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE.
     
 
-UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE
+Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE
   // that flag affects the code only if (wchar_t is 32-bit)
   // that mode with high-escape can be disabled now in UTFConvert.cpp
   if (flag is NOT set)
@@ -228,19 +228,19 @@ Main use cases:
 
 WIN32 : UTF-16-RAW -> UTF-8 (archive) -> UTF-16-RAW
    {
-     Do NOT set UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE.
-     Do NOT set UTF_FLAG__TO_UTF8__SURROGATE_ERROR.
+     Do NOT set Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE.
+     Do NOT set Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR.
      So we restore original UTF-16-RAW.
    }
 
 Linix : UTF-8 with Escapes -> UTF-16 (7z archive) -> UTF-8 with Escapes
-     set UTF_FLAG__TO_UTF8__EXTRACT_BMP_ESCAPE to extract non-UTF from 7z archive
-     set UTF_FLAG__TO_UTF8__PARSE_HIGH_ESCAPE for intermediate UTF-16.
+     set Z7_UTF_FLAG_TO_UTF8_EXTRACT_BMP_ESCAPE to extract non-UTF from 7z archive
+     set Z7_UTF_FLAG_TO_UTF8_PARSE_HIGH_ESCAPE for intermediate UTF-16.
      Note: high esacape mode can be ignored now in UTFConvert.cpp
 
 macOS:
      the system doesn't support incorrect UTF-8 in file names.
-     set UTF_FLAG__TO_UTF8__SURROGATE_ERROR
+     set Z7_UTF_FLAG_TO_UTF8_SURROGATE_ERROR
 */
 
 extern unsigned g_Unicode_To_UTF8_Flags;
@@ -261,7 +261,7 @@ bool Unicode_IsThere_BmpEscape(const UString &src);
 bool Unicode_IsThere_Utf16SurrogateError(const UString &src);
 */
 
-#ifdef _WCHART_IS_16BIT
+#ifdef Z7_WCHART_IS_16BIT
 #define Convert_UnicodeEsc16_To_UnicodeEscHigh(s)
 #else
 void Convert_UnicodeEsc16_To_UnicodeEscHigh(UString &s);
diff --git a/CPP/Common/Wildcard.cpp b/CPP/Common/Wildcard.cpp
index 861f3f7..798cbd9 100644
--- a/CPP/Common/Wildcard.cpp
+++ b/CPP/Common/Wildcard.cpp
@@ -125,8 +125,8 @@ static bool EnhancedMaskTest(const wchar_t *mask, const wchar_t *name)
 {
   for (;;)
   {
-    wchar_t m = *mask;
-    wchar_t c = *name;
+    const wchar_t m = *mask;
+    const wchar_t c = *name;
     if (m == 0)
       return (c == 0);
     if (m == '*')
@@ -526,12 +526,10 @@ int CCensor::FindPairForPrefix(const UString &prefix) const
 
 bool IsDriveColonName(const wchar_t *s)
 {
-  wchar_t c = s[0];
-  return c != 0
-    && s[1] == ':'
-    && s[2] == 0
-    && ((c >= 'a' && c <= 'z')
-     || (c >= 'A' && c <= 'Z'));
+  unsigned c = s[0];
+  c |= 0x20;
+  c -= 'a';
+  return c <= (unsigned)('z' - 'a') && s[1] == ':' && s[2] == 0;
 }
 
 unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts)
diff --git a/CPP/Common/Wildcard.h b/CPP/Common/Wildcard.h
index 0fa4887..4f81da9 100644
--- a/CPP/Common/Wildcard.h
+++ b/CPP/Common/Wildcard.h
@@ -1,7 +1,7 @@
 // Common/Wildcard.h
 
-#ifndef __COMMON_WILDCARD_H
-#define __COMMON_WILDCARD_H
+#ifndef ZIP7_INC_COMMON_WILDCARD_H
+#define ZIP7_INC_COMMON_WILDCARD_H
 
 #include "MyString.h"
 
@@ -83,7 +83,7 @@ public:
   CCensorNode():
       Parent(NULL)
       // , ExcludeDirItems(false)
-      {};
+      {}
 
   CCensorNode(const UString &name, CCensorNode *parent):
       Parent(parent)
diff --git a/CPP/Common/XzCrc64Reg.cpp b/CPP/Common/XzCrc64Reg.cpp
index 33b5249..e9e67ef 100644
--- a/CPP/Common/XzCrc64Reg.cpp
+++ b/CPP/Common/XzCrc64Reg.cpp
@@ -9,34 +9,31 @@
 
 #include "../7zip/Common/RegisterCodec.h"
 
-class CXzCrc64Hasher:
-  public IHasher,
-  public CMyUnknownImp
-{
+Z7_CLASS_IMP_COM_1(
+  CXzCrc64Hasher
+  , IHasher
+)
   UInt64 _crc;
-  Byte mtDummy[1 << 7];
-
 public:
-  CXzCrc64Hasher(): _crc(CRC64_INIT_VAL) {}
+  Byte _mtDummy[1 << 7];  // it's public to eliminate clang warning: unused private field
 
-  MY_UNKNOWN_IMP1(IHasher)
-  INTERFACE_IHasher(;)
+  CXzCrc64Hasher(): _crc(CRC64_INIT_VAL) {}
 };
 
-STDMETHODIMP_(void) CXzCrc64Hasher::Init() throw()
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Init())
 {
   _crc = CRC64_INIT_VAL;
 }
 
-STDMETHODIMP_(void) CXzCrc64Hasher::Update(const void *data, UInt32 size) throw()
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Update(const void *data, UInt32 size))
 {
   _crc = Crc64Update(_crc, data, size);
 }
 
-STDMETHODIMP_(void) CXzCrc64Hasher::Final(Byte *digest) throw()
+Z7_COM7F_IMF2(void, CXzCrc64Hasher::Final(Byte *digest))
 {
-  UInt64 val = CRC64_GET_DIGEST(_crc);
-  SetUi64(digest, val);
+  const UInt64 val = CRC64_GET_DIGEST(_crc);
+  SetUi64(digest, val)
 }
 
 REGISTER_HASHER(CXzCrc64Hasher, 0x4, "CRC64", 8)