react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Client7z/Client7z.cpp

@@ -5,9 +5,10 @@
 #include <stdio.h>
 
 #include "../../../Common/MyWindows.h"
-#include "../../../Common/MyInitGuid.h"
 
 #include "../../../Common/Defs.h"
+#include "../../../Common/MyInitGuid.h"
+
 #include "../../../Common/IntToString.h"
 #include "../../../Common/StringConvert.h"
 
@@ -23,55 +24,30 @@
 
 #include "../../Archive/IArchive.h"
 
-#if 0
-// for password request functions:
-#include "../../UI/Console/UserInputUtils.h"
-#endif
-
 #include "../../IPassword.h"
 #include "../../../../C/7zVersion.h"
 
 #ifdef _WIN32
-extern
-HINSTANCE g_hInstance;
-HINSTANCE g_hInstance = NULL;
+HINSTANCE g_hInstance = 0;
 #endif
 
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
+// Tou can find the list of all GUIDs in Guid.txt file.
+// use another CLSIDs, if you want to support other formats (zip, rar, ...).
+// {23170F69-40C1-278A-1000-000110070000}
 
-// You can find full list of all GUIDs supported by 7-Zip in Guid.txt file.
-// 7z format GUID: {23170F69-40C1-278A-1000-000110070000}
+DEFINE_GUID(CLSID_CFormat7z,
+  0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x07, 0x00, 0x00);
+DEFINE_GUID(CLSID_CFormatXz,
+  0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x0C, 0x00, 0x00);
 
-#define DEFINE_GUID_ARC(name, id) Z7_DEFINE_GUID(name, \
-  0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, id, 0x00, 0x00);
-
-enum
-{
-  kId_Zip = 1,
-  kId_BZip2 = 2,
-  kId_7z = 7,
-  kId_Xz = 0xC,
-  kId_Tar = 0xEE,
-  kId_GZip = 0xEF
-};
-
-// use another id, if you want to support other formats (zip, Xz, ...).
-// DEFINE_GUID_ARC (CLSID_Format, kId_Zip)
-// DEFINE_GUID_ARC (CLSID_Format, kId_BZip2)
-// DEFINE_GUID_ARC (CLSID_Format, kId_Xz)
-// DEFINE_GUID_ARC (CLSID_Format, kId_Tar)
-// DEFINE_GUID_ARC (CLSID_Format, kId_GZip)
-DEFINE_GUID_ARC (CLSID_Format, kId_7z)
+#define CLSID_Format CLSID_CFormat7z
+// #define CLSID_Format CLSID_CFormatXz
 
 using namespace NWindows;
 using namespace NFile;
 using namespace NDir;
 
-#ifdef _WIN32
 #define kDllName "7z.dll"
-#else
-#define kDllName "7z.so"
-#endif
 
 static const char * const kCopyrightString =
   "\n"
@@ -160,7 +136,7 @@ static void PrintError(const char *message, const FString &name)
 static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
 {
   NCOM::CPropVariant prop;
-  RINOK(archive->GetProperty(index, propID, &prop))
+  RINOK(archive->GetProperty(index, propID, &prop));
   if (prop.vt == VT_BOOL)
     result = VARIANT_BOOLToBool(prop.boolVal);
   else if (prop.vt == VT_EMPTY)
@@ -183,13 +159,18 @@ static const wchar_t * const kEmptyFileAlias = L"[Content]";
 // Archive Open callback class
 
 
-class CArchiveOpenCallback Z7_final:
+class CArchiveOpenCallback:
   public IArchiveOpenCallback,
   public ICryptoGetTextPassword,
   public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_2(IArchiveOpenCallback, ICryptoGetTextPassword)
 public:
+  MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
+
+  STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes);
+  STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes);
+
+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
 
   bool PasswordIsDefined;
   UString Password;
@@ -197,28 +178,25 @@ public:
   CArchiveOpenCallback() : PasswordIsDefined(false) {}
 };
 
-Z7_COM7F_IMF(CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */))
+STDMETHODIMP CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */))
+STDMETHODIMP CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */)
 {
   return S_OK;
 }
   
-Z7_COM7F_IMF(CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password))
+STDMETHODIMP CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password)
 {
   if (!PasswordIsDefined)
   {
     // You can ask real password here from user
-#if 0
-    RINOK(GetPassword_HRESULT(&g_StdOut, Password))
-    PasswordIsDefined = true;
-#else
+    // Password = GetPassword(OutStream);
+    // PasswordIsDefined = true;
     PrintError("Password is not defined");
     return E_ABORT;
-#endif
   }
   return StringToBstr(Password, password);
 }
@@ -233,7 +211,6 @@ static const char * const kIncorrectCommand = "incorrect command";
 static const char * const kTestingString    =  "Testing     ";
 static const char * const kExtractingString =  "Extracting  ";
 static const char * const kSkippingString   =  "Skipping    ";
-static const char * const kReadingString    =  "Reading     ";
 
 static const char * const kUnsupportedMethod = "Unsupported Method";
 static const char * const kCRCFailed = "CRC Failed";
@@ -245,94 +222,27 @@ static const char * const kIsNotArc = "Is not archive";
 static const char * const kHeadersError = "Headers Error";
 
 
-struct CArcTime
-{
-  FILETIME FT;
-  UInt16 Prec;
-  Byte Ns100;
-  bool Def;
-
-  CArcTime()
-  {
-    Clear();
-  }
-
-  void Clear()
-  {
-    FT.dwHighDateTime = FT.dwLowDateTime = 0;
-    Prec = 0;
-    Ns100 = 0;
-    Def = false;
-  }
-
-  bool IsZero() const
-  {
-    return FT.dwLowDateTime == 0 && FT.dwHighDateTime == 0 && Ns100 == 0;
-  }
-
-  int GetNumDigits() const
-  {
-    if (Prec == k_PropVar_TimePrec_Unix ||
-        Prec == k_PropVar_TimePrec_DOS)
-      return 0;
-    if (Prec == k_PropVar_TimePrec_HighPrec)
-      return 9;
-    if (Prec == k_PropVar_TimePrec_0)
-      return 7;
-    int digits = (int)Prec - (int)k_PropVar_TimePrec_Base;
-    if (digits < 0)
-      digits = 0;
-    return digits;
-  }
-
-  void Write_To_FiTime(CFiTime &dest) const
-  {
-   #ifdef _WIN32
-    dest = FT;
-   #else
-    if (FILETIME_To_timespec(FT, dest))
-    if ((Prec == k_PropVar_TimePrec_Base + 8 ||
-         Prec == k_PropVar_TimePrec_Base + 9)
-        && Ns100 != 0)
-    {
-      dest.tv_nsec += Ns100;
-    }
-   #endif
-  }
-
-  void Set_From_Prop(const PROPVARIANT &prop)
-  {
-    FT = prop.filetime;
-    unsigned prec = 0;
-    unsigned ns100 = 0;
-    const unsigned prec_Temp = prop.wReserved1;
-    if (prec_Temp != 0
-        && prec_Temp <= k_PropVar_TimePrec_1ns
-        && prop.wReserved3 == 0)
-    {
-      const unsigned ns100_Temp = prop.wReserved2;
-      if (ns100_Temp < 100)
-      {
-        ns100 = ns100_Temp;
-        prec = prec_Temp;
-      }
-    }
-    Prec = (UInt16)prec;
-    Ns100 = (Byte)ns100;
-    Def = true;
-  }
-};
-
-
-
-class CArchiveExtractCallback Z7_final:
+class CArchiveExtractCallback:
   public IArchiveExtractCallback,
   public ICryptoGetTextPassword,
   public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_2(IArchiveExtractCallback, ICryptoGetTextPassword)
-  Z7_IFACE_COM7_IMP(IProgress)
+public:
+  MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
+
+  // IProgress
+  STDMETHOD(SetTotal)(UInt64 size);
+  STDMETHOD(SetCompleted)(const UInt64 *completeValue);
+
+  // IArchiveExtractCallback
+  STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode);
+  STDMETHOD(PrepareOperation)(Int32 askExtractMode);
+  STDMETHOD(SetOperationResult)(Int32 resultEOperationResult);
 
+  // ICryptoGetTextPassword
+  STDMETHOD(CryptoGetTextPassword)(BSTR *aPassword);
+
+private:
   CMyComPtr<IInArchive> _archiveHandler;
   FString _directoryPath;  // Output directory
   UString _filePath;       // name inside arcvhive
@@ -340,10 +250,11 @@ class CArchiveExtractCallback Z7_final:
   bool _extractMode;
   struct CProcessedFileInfo
   {
-    CArcTime MTime;
+    FILETIME MTime;
     UInt32 Attrib;
     bool isDir;
-    bool Attrib_Defined;
+    bool AttribDefined;
+    bool MTimeDefined;
   } _processedFileInfo;
 
   COutFileStream *_outFileStreamSpec;
@@ -367,26 +278,26 @@ void CArchiveExtractCallback::Init(IInArchive *archiveHandler, const FString &di
   NName::NormalizeDirPathPrefix(_directoryPath);
 }
 
-Z7_COM7F_IMF(CArchiveExtractCallback::SetTotal(UInt64 /* size */))
+STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 /* size */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */))
+STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
-    ISequentialOutStream **outStream, Int32 askExtractMode))
+STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index,
+    ISequentialOutStream **outStream, Int32 askExtractMode)
 {
-  *outStream = NULL;
+  *outStream = 0;
   _outFileStream.Release();
 
   {
     // Get Name
     NCOM::CPropVariant prop;
-    RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop))
+    RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop));
     
     UString fullPath;
     if (prop.vt == VT_EMPTY)
@@ -406,35 +317,36 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
   {
     // Get Attrib
     NCOM::CPropVariant prop;
-    RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop))
+    RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop));
     if (prop.vt == VT_EMPTY)
     {
       _processedFileInfo.Attrib = 0;
-      _processedFileInfo.Attrib_Defined = false;
+      _processedFileInfo.AttribDefined = false;
     }
     else
     {
       if (prop.vt != VT_UI4)
         return E_FAIL;
       _processedFileInfo.Attrib = prop.ulVal;
-      _processedFileInfo.Attrib_Defined = true;
+      _processedFileInfo.AttribDefined = true;
     }
   }
 
-  RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.isDir))
+  RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.isDir));
 
   {
-    _processedFileInfo.MTime.Clear();
     // Get Modified Time
     NCOM::CPropVariant prop;
-    RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop))
+    RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop));
+    _processedFileInfo.MTimeDefined = false;
     switch (prop.vt)
     {
       case VT_EMPTY:
         // _processedFileInfo.MTime = _utcMTimeDefault;
         break;
       case VT_FILETIME:
-        _processedFileInfo.MTime.Set_From_Prop(prop);
+        _processedFileInfo.MTime = prop.filetime;
+        _processedFileInfo.MTimeDefined = true;
         break;
       default:
         return E_FAIL;
@@ -444,7 +356,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
   {
     // Get Size
     NCOM::CPropVariant prop;
-    RINOK(_archiveHandler->GetProperty(index, kpidSize, &prop))
+    RINOK(_archiveHandler->GetProperty(index, kpidSize, &prop));
     UInt64 newFileSize;
     /* bool newFileSizeDefined = */ ConvertPropVariantToUInt64(prop, newFileSize);
   }
@@ -471,16 +383,16 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
     {
       if (!DeleteFileAlways(fullProcessedPath))
       {
-        PrintError("Cannot delete output file", fullProcessedPath);
+        PrintError("Can not delete output file", fullProcessedPath);
         return E_ABORT;
       }
     }
     
     _outFileStreamSpec = new COutFileStream;
     CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
-    if (!_outFileStreamSpec->Create_ALWAYS(fullProcessedPath))
+    if (!_outFileStreamSpec->Open(fullProcessedPath, CREATE_ALWAYS))
     {
-      PrintError("Cannot open output file", fullProcessedPath);
+      PrintError("Can not open output file", fullProcessedPath);
       return E_ABORT;
     }
     _outFileStream = outStreamLoc;
@@ -489,27 +401,24 @@ Z7_COM7F_IMF(CArchiveExtractCallback::GetStream(UInt32 index,
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode))
+STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
 {
   _extractMode = false;
   switch (askExtractMode)
   {
     case NArchive::NExtract::NAskMode::kExtract:  _extractMode = true; break;
-  }
+  };
   switch (askExtractMode)
   {
     case NArchive::NExtract::NAskMode::kExtract:  Print(kExtractingString); break;
     case NArchive::NExtract::NAskMode::kTest:  Print(kTestingString); break;
     case NArchive::NExtract::NAskMode::kSkip:  Print(kSkippingString); break;
-    case NArchive::NExtract::NAskMode::kReadExternal: Print(kReadingString); break;
-    default:
-      Print("??? "); break;
-  }
+  };
   Print(_filePath);
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 operationResult))
+STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 operationResult)
 {
   switch (operationResult)
   {
@@ -555,7 +464,7 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 operationResult))
       else
       {
         char temp[16];
-        ConvertUInt32ToString((UInt32)operationResult, temp);
+        ConvertUInt32ToString(operationResult, temp);
         Print("Error #");
         Print(temp);
       }
@@ -564,34 +473,27 @@ Z7_COM7F_IMF(CArchiveExtractCallback::SetOperationResult(Int32 operationResult))
 
   if (_outFileStream)
   {
-    if (_processedFileInfo.MTime.Def)
-    {
-      CFiTime ft;
-      _processedFileInfo.MTime.Write_To_FiTime(ft);
-      _outFileStreamSpec->SetMTime(&ft);
-    }
-    RINOK(_outFileStreamSpec->Close())
+    if (_processedFileInfo.MTimeDefined)
+      _outFileStreamSpec->SetMTime(&_processedFileInfo.MTime);
+    RINOK(_outFileStreamSpec->Close());
   }
   _outFileStream.Release();
-  if (_extractMode && _processedFileInfo.Attrib_Defined)
+  if (_extractMode && _processedFileInfo.AttribDefined)
     SetFileAttrib_PosixHighDetect(_diskFilePath, _processedFileInfo.Attrib);
   PrintNewLine();
   return S_OK;
 }
 
 
-Z7_COM7F_IMF(CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password))
+STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
 {
   if (!PasswordIsDefined)
   {
-#if 0
     // You can ask real password here from user
-    RINOK(GetPassword_HRESULT(&g_StdOut, Password))
-    PasswordIsDefined = true;
-#else
+    // Password = GetPassword(OutStream);
+    // PasswordIsDefined = true;
     PrintError("Password is not defined");
     return E_ABORT;
-#endif
   }
   return StringToBstr(Password, password);
 }
@@ -601,24 +503,41 @@ Z7_COM7F_IMF(CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password))
 //////////////////////////////////////////////////////////////
 // Archive Creating callback class
 
-struct CDirItem: public NWindows::NFile::NFind::CFileInfoBase
+struct CDirItem
 {
-  UString Path_For_Handler;
-  FString FullPath; // for filesystem
+  UInt64 Size;
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+  UString Name;
+  FString FullPath;
+  UInt32 Attrib;
 
-  CDirItem(const NWindows::NFile::NFind::CFileInfo &fi):
-      CFileInfoBase(fi)
-    {}
+  bool isDir() const { return (Attrib & FILE_ATTRIBUTE_DIRECTORY) != 0 ; }
 };
 
-class CArchiveUpdateCallback Z7_final:
+class CArchiveUpdateCallback:
   public IArchiveUpdateCallback2,
   public ICryptoGetTextPassword2,
   public CMyUnknownImp
 {
-  Z7_IFACES_IMP_UNK_2(IArchiveUpdateCallback2, ICryptoGetTextPassword2)
-  Z7_IFACE_COM7_IMP(IProgress)
-  Z7_IFACE_COM7_IMP(IArchiveUpdateCallback)
+public:
+  MY_UNKNOWN_IMP2(IArchiveUpdateCallback2, ICryptoGetTextPassword2)
+
+  // IProgress
+  STDMETHOD(SetTotal)(UInt64 size);
+  STDMETHOD(SetCompleted)(const UInt64 *completeValue);
+
+  // IUpdateCallback2
+  STDMETHOD(GetUpdateItemInfo)(UInt32 index,
+      Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive);
+  STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **inStream);
+  STDMETHOD(SetOperationResult)(Int32 operationResult);
+  STDMETHOD(GetVolumeSize)(UInt32 index, UInt64 *size);
+  STDMETHOD(GetVolumeStream)(UInt32 index, ISequentialOutStream **volumeStream);
+
+  STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password);
 
 public:
   CRecordVector<UInt64> VolumesSizes;
@@ -637,11 +556,7 @@ public:
   FStringVector FailedFiles;
   CRecordVector<HRESULT> FailedCodes;
 
-  CArchiveUpdateCallback():
-      DirItems(NULL),
-      PasswordIsDefined(false),
-      AskPassword(false)
-      {}
+  CArchiveUpdateCallback(): PasswordIsDefined(false), AskPassword(false), DirItems(0) {};
 
   ~CArchiveUpdateCallback() { Finilize(); }
   HRESULT Finilize();
@@ -655,18 +570,18 @@ public:
   }
 };
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::SetTotal(UInt64 /* size */))
+STDMETHODIMP CArchiveUpdateCallback::SetTotal(UInt64 /* size */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::SetCompleted(const UInt64 * /* completeValue */))
+STDMETHODIMP CArchiveUpdateCallback::SetCompleted(const UInt64 * /* completeValue */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
-      Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive))
+STDMETHODIMP CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
+      Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive)
 {
   if (newData)
     *newData = BoolToInt(true);
@@ -677,7 +592,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   NCOM::CPropVariant prop;
   
@@ -689,17 +604,16 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PR
   }
 
   {
-    const CDirItem &di = (*DirItems)[index];
+    const CDirItem &dirItem = (*DirItems)[index];
     switch (propID)
     {
-      case kpidPath:  prop = di.Path_For_Handler; break;
-      case kpidIsDir:  prop = di.IsDir(); break;
-      case kpidSize:  prop = di.Size; break;
-      case kpidCTime:  PropVariant_SetFrom_FiTime(prop, di.CTime); break;
-      case kpidATime:  PropVariant_SetFrom_FiTime(prop, di.ATime); break;
-      case kpidMTime:  PropVariant_SetFrom_FiTime(prop, di.MTime); break;
-      case kpidAttrib:  prop = (UInt32)di.GetWinAttrib(); break;
-      case kpidPosixAttrib: prop = (UInt32)di.GetPosixAttrib(); break;
+      case kpidPath:  prop = dirItem.Name; break;
+      case kpidIsDir:  prop = dirItem.isDir(); break;
+      case kpidSize:  prop = dirItem.Size; break;
+      case kpidAttrib:  prop = dirItem.Attrib; break;
+      case kpidCTime:  prop = dirItem.CTime; break;
+      case kpidATime:  prop = dirItem.ATime; break;
+      case kpidMTime:  prop = dirItem.MTime; break;
     }
   }
   prop.Detach(value);
@@ -724,14 +638,14 @@ static void GetStream2(const wchar_t *name)
   Print(name);
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream))
+STDMETHODIMP CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream)
 {
-  RINOK(Finilize())
+  RINOK(Finilize());
 
   const CDirItem &dirItem = (*DirItems)[index];
-  GetStream2(dirItem.Path_For_Handler);
+  GetStream2(dirItem.Name);
  
-  if (dirItem.IsDir())
+  if (dirItem.isDir())
     return S_OK;
 
   {
@@ -740,8 +654,8 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream
     FString path = DirPrefix + dirItem.FullPath;
     if (!inStreamSpec->Open(path))
     {
-      const DWORD sysError = ::GetLastError();
-      FailedCodes.Add(HRESULT_FROM_WIN32(sysError));
+      DWORD sysError = ::GetLastError();
+      FailedCodes.Add(sysError);
       FailedFiles.Add(path);
       // if (systemError == ERROR_SHARING_VIOLATION)
       {
@@ -757,13 +671,13 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::SetOperationResult(Int32 /* operationResult */))
+STDMETHODIMP CArchiveUpdateCallback::SetOperationResult(Int32 /* operationResult */)
 {
   m_NeedBeClosed = true;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size))
+STDMETHODIMP CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size)
 {
   if (VolumesSizes.Size() == 0)
     return S_FALSE;
@@ -773,7 +687,7 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size))
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream))
+STDMETHODIMP CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)
 {
   wchar_t temp[16];
   ConvertUInt32ToString(index + 1, temp);
@@ -781,30 +695,28 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOu
   while (res.Len() < 2)
     res.InsertAtFront(L'0');
   UString fileName = VolName;
-  fileName.Add_Dot();
+  fileName += '.';
   fileName += res;
   fileName += VolExt;
   COutFileStream *streamSpec = new COutFileStream;
   CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
-  if (!streamSpec->Create_NEW(us2fs(fileName)))
-    return GetLastError_noZero_HRESULT();
+  if (!streamSpec->Create(us2fs(fileName), false))
+    return ::GetLastError();
   *volumeStream = streamLoc.Detach();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
 {
   if (!PasswordIsDefined)
   {
     if (AskPassword)
     {
-#if 0
-      RINOK(GetPassword_HRESULT(&g_StdOut, Password))
-      PasswordIsDefined = true;
-#else
+      // You can ask real password here from user
+      // Password = GetPassword(OutStream);
+      // PasswordIsDefined = true;
       PrintError("Password is not defined");
       return E_ABORT;
-#endif
     }
   }
   *passwordIsDefined = BoolToInt(PasswordIsDefined);
@@ -814,18 +726,12 @@ Z7_COM7F_IMF(CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDef
 
 // Main function
 
-#if defined(_UNICODE) && !defined(_WIN64) && !defined(UNDER_CE)
 #define NT_CHECK_FAIL_ACTION PrintError("Unsupported Windows version"); return 1;
-#endif
 
-int Z7_CDECL main(int numArgs, const char *args[])
+int MY_CDECL main(int numArgs, const char *args[])
 {
   NT_CHECK
 
-  #ifdef ENV_HAVE_LOCALE
-  MY_SetLocale();
-  #endif
-
   PrintStringLn(kCopyrightString);
 
   if (numArgs < 2)
@@ -834,106 +740,55 @@ int Z7_CDECL main(int numArgs, const char *args[])
     return 0;
   }
 
-  FString dllPrefix;
-
-  #ifdef _WIN32
-  dllPrefix = NDLL::GetModuleDirPrefix();
-  #else
+  if (numArgs < 3)
   {
-    AString s (args[0]);
-    int sep = s.ReverseFind_PathSepar();
-    s.DeleteFrom(sep + 1);
-    dllPrefix = s;
+    PrintError(kIncorrectCommand);
+    return 1;
   }
-  #endif
 
+  
   NDLL::CLibrary lib;
-  if (!lib.Load(dllPrefix + FTEXT(kDllName)))
+  if (!lib.Load(NDLL::GetModuleDirPrefix() + FTEXT(kDllName)))
   {
-    PrintError("Cannot load 7-zip library");
+    PrintError("Can not load 7-zip library");
     return 1;
   }
 
-#if defined(__clang__)
-#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
-#endif
-
-#ifdef _WIN32
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
-#endif
-
-  Func_CreateObject
-     f_CreateObject = Z7_GET_PROC_ADDRESS(
-  Func_CreateObject, lib.Get_HMODULE(),
-      "CreateObject");
-  if (!f_CreateObject)
+  Func_CreateObject createObjectFunc = (Func_CreateObject)lib.GetProc("CreateObject");
+  if (!createObjectFunc)
   {
-    PrintError("Cannot get CreateObject");
+    PrintError("Can not get CreateObject");
     return 1;
   }
 
-  char c = 0;
-  UString password;
-  bool passwordIsDefined = false;
-  CObjectVector<FString> params;
-
-  for (int curCmd = 1; curCmd < numArgs; curCmd++)
+  char c;
   {
-    AString a(args[curCmd]);
-
-    if (!a.IsEmpty())
-    {
-      if (a[0] == '-')
-      {
-        if (!passwordIsDefined && a[1] == 'p')
-        {
-          password = GetUnicodeString(a.Ptr(2));
-          passwordIsDefined = true;
-          continue;
-        }
-      }
-      else
-      {
-        if (c)
-        {
-          params.Add(CmdStringToFString(a));
-          continue;
-        }
-        if (a.Len() == 1)
-        {
-          c = (char)MyCharLower_Ascii(a[0]);
-          continue;
-        }
-      }
-    }
+    AString command (args[1]);
+    if (command.Len() != 1)
     {
       PrintError(kIncorrectCommand);
       return 1;
     }
+    c = (char)MyCharLower_Ascii(command[0]);
   }
 
-  if (!c || params.Size() < 1)
-  {
-    PrintError(kIncorrectCommand);
-    return 1;
-  }
-
-  const FString &archiveName = params[0];
+  FString archiveName = CmdStringToFString(args[2]);
   
   if (c == 'a')
   {
     // create archive command
-    if (params.Size() < 2)
+    if (numArgs < 4)
     {
       PrintError(kIncorrectCommand);
       return 1;
     }
     CObjectVector<CDirItem> dirItems;
     {
-      unsigned i;
-      for (i = 1; i < params.Size(); i++)
+      int i;
+      for (i = 3; i < numArgs; i++)
       {
-        const FString &name = params[i];
+        CDirItem di;
+        FString name = CmdStringToFString(args[i]);
         
         NFind::CFileInfo fi;
         if (!fi.Find(name))
@@ -941,10 +796,13 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
           PrintError("Can't find file", name);
           return 1;
         }
-
-        CDirItem di(fi);
         
-        di.Path_For_Handler = fs2us(name);
+        di.Attrib = fi.Attrib;
+        di.Size = fi.Size;
+        di.CTime = fi.CTime;
+        di.ATime = fi.ATime;
+        di.MTime = fi.MTime;
+        di.Name = fs2us(name);
         di.FullPath = name;
         dirItems.Add(di);
       }
@@ -952,37 +810,35 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
 
     COutFileStream *outFileStreamSpec = new COutFileStream;
     CMyComPtr<IOutStream> outFileStream = outFileStreamSpec;
-    if (!outFileStreamSpec->Create_NEW(archiveName))
+    if (!outFileStreamSpec->Create(archiveName, false))
     {
       PrintError("can't create archive file");
       return 1;
     }
 
     CMyComPtr<IOutArchive> outArchive;
-    if (f_CreateObject(&CLSID_Format, &IID_IOutArchive, (void **)&outArchive) != S_OK)
+    if (createObjectFunc(&CLSID_Format, &IID_IOutArchive, (void **)&outArchive) != S_OK)
     {
-      PrintError("Cannot get class object");
+      PrintError("Can not get class object");
       return 1;
     }
 
     CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
     CMyComPtr<IArchiveUpdateCallback2> updateCallback(updateCallbackSpec);
     updateCallbackSpec->Init(&dirItems);
-    updateCallbackSpec->PasswordIsDefined = passwordIsDefined;
-    updateCallbackSpec->Password = password;
+    // updateCallbackSpec->PasswordIsDefined = true;
+    // updateCallbackSpec->Password = L"1";
 
     /*
     {
       const wchar_t *names[] =
       {
-        L"m",
         L"s",
         L"x"
       };
-      const unsigned kNumProps = Z7_ARRAY_SIZE(names);
+      const unsigned kNumProps = ARRAY_SIZE(names);
       NCOM::CPropVariant values[kNumProps] =
       {
-        L"lzma",
         false,    // solid mode OFF
         (UInt32)9 // compression level = 9 - ultra
       };
@@ -993,11 +849,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
         PrintError("ISetProperties unsupported");
         return 1;
       }
-      if (setProperties->SetProperties(names, values, kNumProps) != S_OK)
-      {
-        PrintError("SetProperties() error");
-        return 1;
-      }
+      RINOK(setProperties->SetProperties(names, values, kNumProps));
     }
     */
     
@@ -1022,7 +874,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
   }
   else
   {
-    if (params.Size() != 1)
+    if (numArgs != 3)
     {
       PrintError(kIncorrectCommand);
       return 1;
@@ -1041,9 +893,9 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
     }
   
     CMyComPtr<IInArchive> archive;
-    if (f_CreateObject(&CLSID_Format, &IID_IInArchive, (void **)&archive) != S_OK)
+    if (createObjectFunc(&CLSID_Format, &IID_IInArchive, (void **)&archive) != S_OK)
     {
-      PrintError("Cannot get class object");
+      PrintError("Can not get class object");
       return 1;
     }
     
@@ -1052,20 +904,21 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
     
     if (!fileSpec->Open(archiveName))
     {
-      PrintError("Cannot open archive file", archiveName);
+      PrintError("Can not open archive file", archiveName);
       return 1;
     }
 
     {
       CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
       CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
-      openCallbackSpec->PasswordIsDefined = passwordIsDefined;
-      openCallbackSpec->Password = password;
+      openCallbackSpec->PasswordIsDefined = false;
+      // openCallbackSpec->PasswordIsDefined = true;
+      // openCallbackSpec->Password = L"1";
       
       const UInt64 scanSize = 1 << 23;
       if (archive->Open(file, &scanSize, openCallback) != S_OK)
       {
-        PrintError("Cannot open file as archive", archiveName);
+        PrintError("Can not open file as archive", archiveName);
         return 1;
       }
     }
@@ -1081,7 +934,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
           // Get uncompressed size of file
           NCOM::CPropVariant prop;
           archive->GetProperty(i, kpidSize, &prop);
-          char s[64];
+          char s[32];
           ConvertPropVariantToShortString(prop, s);
           Print(s);
           Print("  ");
@@ -1104,8 +957,9 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
       CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
       extractCallbackSpec->Init(archive, FString()); // second parameter is output folder path
-      extractCallbackSpec->PasswordIsDefined = passwordIsDefined;
-      extractCallbackSpec->Password = password;
+      extractCallbackSpec->PasswordIsDefined = false;
+      // extractCallbackSpec->PasswordIsDefined = true;
+      // extractCallbackSpec->Password = "1";
 
       /*
       const wchar_t *names[] =
@@ -1122,13 +976,7 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       CMyComPtr<ISetProperties> setProperties;
       archive->QueryInterface(IID_ISetProperties, (void **)&setProperties);
       if (setProperties)
-      {
-        if (setProperties->SetProperties(names, values, kNumProps) != S_OK)
-        {
-          PrintError("SetProperties() error");
-          return 1;
-        }
-      }
+        setProperties->SetProperties(names, values, kNumProps);
       */
 
       HRESULT result = archive->Extract(NULL, (UInt32)(Int32)(-1), false, extractCallback);