react-native-update 10.34.3 → 10.34.5

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

@@ -14,7 +14,6 @@
 #include "../../../Common/IntToString.h"
 #include "../../../Common/StringConvert.h"
 #include "../../../Common/StringToInt.h"
-#include "../../../Common/UTFConvert.h"
 #include "../../../Common/Wildcard.h"
 
 #include "../../../Windows/FileDir.h"
@@ -29,17 +28,15 @@
 #include "DefaultName.h"
 #include "OpenArchive.h"
 
-#ifndef Z7_SFX
+#ifndef _SFX
 #include "SetProperties.h"
 #endif
 
-#ifndef Z7_SFX
 #ifdef SHOW_DEBUG_INFO
 #define PRF(x) x
 #else
 #define PRF(x)
 #endif
-#endif
 
 // increase it, if you need to support larger SFX stubs
 static const UInt64 kMaxCheckStartPosition = 1 << 23;
@@ -67,7 +64,7 @@ Open:
         - open FAIL:
            Try to open with all other types from offset 0 only.
            If some open type is OK and physical archive size is uequal or larger
-           than file size, then return that archive with warning that cannot be open as [extension type].
+           than file size, then return that archive with warning that can not be open as [extension type].
            If extension was EXE, it will try to open as unknown_extension case
     - file has unknown extension (like a.hhh)
        It tries to open via parser code.
@@ -95,7 +92,7 @@ Open:
 using namespace NWindows;
 
 /*
-#ifdef Z7_SFX
+#ifdef _SFX
 #define OPEN_PROPS_PARAM
 #else
 #define OPEN_PROPS_PARAM  , props
@@ -111,7 +108,7 @@ CArc::~CArc()
 }
 */
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 namespace NArchive {
 namespace NParser {
@@ -144,14 +141,14 @@ struct CParseItem
   bool LenIsUnknown;
 
   CParseItem():
-      // OkSize(0),
+      LenIsUnknown(false),
       FileTime_Defined(false),
       UnpackSize_Defined(false),
-      NumSubDirs_Defined(false),
       NumSubFiles_Defined(false),
+      NumSubDirs_Defined(false),
       IsSelfExe(false),
-      IsNotArcType(false),
-      LenIsUnknown(false)
+      IsNotArcType(false)
+      // OkSize(0)
     {}
 
   /*
@@ -172,14 +169,23 @@ struct CParseItem
   }
 };
 
-Z7_CLASS_IMP_CHandler_IInArchive_1(
-  IInArchiveGetStream
-)
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
 public:
   CObjectVector<CParseItem> _items;
   UInt64 _maxEndOffset;
   CMyComPtr<IInStream> _stream;
 
+  MY_UNKNOWN_IMP2(
+    IInArchive,
+    IInArchiveGetStream)
+
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+
   UInt64 GetLastEnd() const
   {
     if (_items.IsEmpty())
@@ -200,25 +206,23 @@ int CHandler::FindInsertPos(const CParseItem &item) const
   unsigned left = 0, right = _items.Size();
   while (left != right)
   {
-    const unsigned mid = (unsigned)(((size_t)left + (size_t)right) / 2);
-    const CParseItem &midItem = _items[mid];
+    unsigned mid = (left + right) / 2;
+    const CParseItem & midItem = _items[mid];
     if (item.Offset < midItem.Offset)
       right = mid;
     else if (item.Offset > midItem.Offset)
       left = mid + 1;
     else if (item.Size < midItem.Size)
       right = mid;
-    /*
     else if (item.Size > midItem.Size)
       left = mid + 1;
-    */
     else
     {
       left = mid + 1;
       // return -1;
     }
   }
-  return (int)left;
+  return left;
 }
 
 void CHandler::AddUnknownItem(UInt64 next)
@@ -253,10 +257,10 @@ void CHandler::AddUnknownItem(UInt64 next)
 void CHandler::AddItem(const CParseItem &item)
 {
   AddUnknownItem(item.Offset);
-  const int pos = FindInsertPos(item);
-  if (pos != -1)
+  int pos = FindInsertPos(item);
+  if (pos >= 0)
   {
-    _items.Insert((unsigned)pos, item);
+    _items.Insert(pos, item);
     UInt64 next = item.Offset + item.Size;
     if (_maxEndOffset < next)
       _maxEndOffset = next;
@@ -291,7 +295,7 @@ static const Byte kProps[] =
 IMP_IInArchive_Props
 IMP_IInArchive_ArcProps_NO
 
-Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */))
+STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */)
 {
   COM_TRY_BEGIN
   {
@@ -302,20 +306,20 @@ Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallb
   COM_TRY_END
 }
 
-Z7_COM7F_IMF(CHandler::Close())
+STDMETHODIMP CHandler::Close()
 {
   _items.Clear();
   _stream.Release();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
 {
   *numItems = _items.Size();
   return S_OK;
 }
 
-Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
   NCOM::CPropVariant prop;
@@ -331,12 +335,12 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
       UString s(sz);
       if (!item.Name.IsEmpty())
       {
-        s.Add_Dot();
+        s += '.';
         s += item.Name;
       }
       if (!item.Extension.IsEmpty())
       {
-        s.Add_Dot();
+        s += '.';
         s += item.Extension;
       }
       prop = s; break;
@@ -350,19 +354,18 @@ Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
     case kpidMTime: if (item.FileTime_Defined) prop = item.FileTime; break;
     case kpidComment: if (!item.Comment.IsEmpty()) prop = item.Comment; break;
     case kpidType: if (!item.ArcType.IsEmpty()) prop = item.ArcType; break;
-    default: break;
   }
   prop.Detach(value);
   return S_OK;
   COM_TRY_END
 }
 
-Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback))
+HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
 {
   COM_TRY_BEGIN
   
-  const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
   if (allFilesMode)
     numItems = _items.Size();
   if (_stream && numItems == 0)
@@ -393,35 +396,35 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   {
     lps->InSize = totalSize;
     lps->OutSize = totalSize;
-    RINOK(lps->SetCur())
+    RINOK(lps->SetCur());
     CMyComPtr<ISequentialOutStream> realOutStream;
-    const Int32 askMode = testMode ?
+    Int32 askMode = testMode ?
         NExtract::NAskMode::kTest :
         NExtract::NAskMode::kExtract;
-    const UInt32 index = allFilesMode ? i : indices[i];
+    Int32 index = allFilesMode ? i : indices[i];
     const CParseItem &item = _items[index];
 
-    RINOK(extractCallback->GetStream(index, &realOutStream, askMode))
+    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
     UInt64 unpackSize = item.Size;
     totalSize += unpackSize;
     bool skipMode = false;
     if (!testMode && !realOutStream)
       continue;
-    RINOK(extractCallback->PrepareOperation(askMode))
+    RINOK(extractCallback->PrepareOperation(askMode));
 
     outStreamSpec->SetStream(realOutStream);
     realOutStream.Release();
     outStreamSpec->Init(skipMode ? 0 : unpackSize, true);
 
     Int32 opRes = NExtract::NOperationResult::kOK;
-    RINOK(InStream_SeekSet(_stream, item.Offset))
+    RINOK(_stream->Seek(item.Offset, STREAM_SEEK_SET, NULL));
     streamSpec->Init(unpackSize);
-    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress))
+    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
 
     if (outStreamSpec->GetRem() != 0)
       opRes = NExtract::NOperationResult::kDataError;
     outStreamSpec->ReleaseStream();
-    RINOK(extractCallback->SetOperationResult(opRes))
+    RINOK(extractCallback->SetOperationResult(opRes));
   }
   
   return S_OK;
@@ -430,7 +433,7 @@ Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
 }
 
 
-Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
 {
   COM_TRY_BEGIN
   const CParseItem &item = _items[index];
@@ -446,7 +449,7 @@ HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bo
 {
   NCOM::CPropVariant prop;
   result = false;
-  RINOK(arc->GetProperty(index, propID, &prop))
+  RINOK(arc->GetProperty(index, propID, &prop));
   if (prop.vt == VT_BOOL)
     result = VARIANT_BOOLToBool(prop.boolVal);
   else if (prop.vt != VT_EMPTY)
@@ -474,11 +477,11 @@ HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &result) thro
   return Archive_GetItemBoolProp(arc, index, kpidIsDeleted, result);
 }
 
-static HRESULT Archive_GetArcProp_Bool(IInArchive *arc, PROPID propid, bool &result) throw()
+static HRESULT Archive_GetArcBoolProp(IInArchive *arc, PROPID propid, bool &result) throw()
 {
   NCOM::CPropVariant prop;
   result = false;
-  RINOK(arc->GetArchiveProperty(propid, &prop))
+  RINOK(arc->GetArchiveProperty(propid, &prop));
   if (prop.vt == VT_BOOL)
     result = VARIANT_BOOLToBool(prop.boolVal);
   else if (prop.vt != VT_EMPTY)
@@ -490,17 +493,16 @@ static HRESULT Archive_GetArcProp_UInt(IInArchive *arc, PROPID propid, UInt64 &r
 {
   defined = false;
   NCOM::CPropVariant prop;
-  RINOK(arc->GetArchiveProperty(propid, &prop))
+  RINOK(arc->GetArchiveProperty(propid, &prop));
   switch (prop.vt)
   {
-    case VT_UI4: result = prop.ulVal; break;
-    case VT_I4:  result = (UInt64)(Int64)prop.lVal; break;
-    case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; break;
-    case VT_I8:  result = (UInt64)prop.hVal.QuadPart; break;
-    case VT_EMPTY: return S_OK;
+    case VT_UI4: result = prop.ulVal; defined = true; break;
+    case VT_I4: result = (Int64)prop.lVal; defined = true; break;
+    case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; defined = true; break;
+    case VT_I8: result = (UInt64)prop.hVal.QuadPart; defined = true; break;
+    case VT_EMPTY: break;
     default: return E_FAIL;
   }
-  defined = true;
   return S_OK;
 }
 
@@ -508,23 +510,22 @@ static HRESULT Archive_GetArcProp_Int(IInArchive *arc, PROPID propid, Int64 &res
 {
   defined = false;
   NCOM::CPropVariant prop;
-  RINOK(arc->GetArchiveProperty(propid, &prop))
+  RINOK(arc->GetArchiveProperty(propid, &prop));
   switch (prop.vt)
   {
-    case VT_UI4: result = prop.ulVal; break;
-    case VT_I4:  result = prop.lVal; break;
-    case VT_UI8: result = (Int64)prop.uhVal.QuadPart; break;
-    case VT_I8:  result = (Int64)prop.hVal.QuadPart; break;
-    case VT_EMPTY: return S_OK;
+    case VT_UI4: result = prop.ulVal; defined = true; break;
+    case VT_I4: result = prop.lVal; defined = true; break;
+    case VT_UI8: result = (Int64)prop.uhVal.QuadPart; defined = true; break;
+    case VT_I8: result = (Int64)prop.hVal.QuadPart; defined = true; break;
+    case VT_EMPTY: break;
     default: return E_FAIL;
   }
-  defined = true;
   return S_OK;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
-HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
+HRESULT CArc::GetItemPathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
 {
   if (!GetRawProps)
     return E_FAIL;
@@ -542,14 +543,14 @@ HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &p
     const void *p;
     UInt32 size;
     UInt32 propType;
-    RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType))
+    RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType));
     if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
       s = (const wchar_t *)p;
     else
     #endif
     {
       NCOM::CPropVariant prop;
-      RINOK(Archive->GetProperty(curIndex, kpidName, &prop))
+      RINOK(Archive->GetProperty(curIndex, kpidName, &prop));
       if (prop.vt == VT_BSTR && prop.bstrVal)
         s.SetFromBstr(prop.bstrVal);
       else if (prop.vt == VT_EMPTY)
@@ -560,7 +561,7 @@ HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &p
 
     UInt32 curParent = (UInt32)(Int32)-1;
     UInt32 parentType = 0;
-    RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType))
+    RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType));
 
     // 18.06: fixed : we don't want to split name to parts
     /*
@@ -585,7 +586,7 @@ HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &p
     {
       {
         UString &s2 = parts[parts.Size() - 2];
-        s2.Add_Colon();
+        s2 += ':';
         s2 += parts.Back();
       }
       parts.DeleteBack();
@@ -606,9 +607,7 @@ HRESULT CArc::GetItem_PathToParent(UInt32 index, UInt32 parent, UStringVector &p
 
 #endif
 
-
-
-HRESULT CArc::GetItem_Path(UInt32 index, UString &result) const
+HRESULT CArc::GetItemPath(UInt32 index, UString &result) const
 {
   #ifdef MY_CPU_LE
   if (GetRawProps)
@@ -622,42 +621,19 @@ HRESULT CArc::GetItem_Path(UInt32 index, UString &result) const
           propType == NPropDataType::kUtf16z)
       {
         unsigned len = size / 2 - 1;
-        // (len) doesn't include null terminator
-
-        /*
-        #if WCHAR_MAX > 0xffff
-        len = (unsigned)Utf16LE__Get_Num_WCHARs(p, len);
-
-        wchar_t *s = result.GetBuf(len);
-        wchar_t *sEnd = Utf16LE__To_WCHARs_Sep(p, len, s);
-        if (s + len != sEnd) return E_FAIL;
-        *sEnd = 0;
-        
-        #else
-        */
-        
         wchar_t *s = result.GetBuf(len);
         for (unsigned i = 0; i < len; i++)
         {
           wchar_t c = GetUi16(p);
           p = (const void *)((const Byte *)p + 2);
-
           #if WCHAR_PATH_SEPARATOR != L'/'
           if (c == L'/')
             c = WCHAR_PATH_SEPARATOR;
-          else if (c == L'\\')
-            c = WCHAR_IN_FILE_NAME_BACKSLASH_REPLACEMENT; // WSL scheme
           #endif
-
           *s++ = c;
         }
         *s = 0;
-        
-        // #endif
-        
         result.ReleaseBuf_SetLen(len);
-
-        Convert_UnicodeEsc16_To_UnicodeEscHigh(result);
         if (len != 0)
           return S_OK;
       }
@@ -734,7 +710,7 @@ HRESULT CArc::GetItem_Path(UInt32 index, UString &result) const
   
   {
     NCOM::CPropVariant prop;
-    RINOK(Archive->GetProperty(index, kpidPath, &prop))
+    RINOK(Archive->GetProperty(index, kpidPath, &prop));
     if (prop.vt == VT_BSTR && prop.bstrVal)
       result.SetFromBstr(prop.bstrVal);
     else if (prop.vt == VT_EMPTY)
@@ -744,25 +720,23 @@ HRESULT CArc::GetItem_Path(UInt32 index, UString &result) const
   }
   
   if (result.IsEmpty())
-    return GetItem_DefaultPath(index, result);
-
-  Convert_UnicodeEsc16_To_UnicodeEscHigh(result);
+    return GetDefaultItemPath(index, result);
   return S_OK;
 }
 
-HRESULT CArc::GetItem_DefaultPath(UInt32 index, UString &result) const
+HRESULT CArc::GetDefaultItemPath(UInt32 index, UString &result) const
 {
   result.Empty();
   bool isDir;
-  RINOK(Archive_IsItem_Dir(Archive, index, isDir))
+  RINOK(Archive_IsItem_Dir(Archive, index, isDir));
   if (!isDir)
   {
     result = DefaultName;
     NCOM::CPropVariant prop;
-    RINOK(Archive->GetProperty(index, kpidExtension, &prop))
+    RINOK(Archive->GetProperty(index, kpidExtension, &prop));
     if (prop.vt == VT_BSTR)
     {
-      result.Add_Dot();
+      result += '.';
       result += prop.bstrVal;
     }
     else if (prop.vt != VT_EMPTY)
@@ -771,13 +745,13 @@ HRESULT CArc::GetItem_DefaultPath(UInt32 index, UString &result) const
   return S_OK;
 }
 
-HRESULT CArc::GetItem_Path2(UInt32 index, UString &result) const
+HRESULT CArc::GetItemPath2(UInt32 index, UString &result) const
 {
-  RINOK(GetItem_Path(index, result))
+  RINOK(GetItemPath(index, result));
   if (Ask_Deleted)
   {
     bool isDeleted = false;
-    RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted))
+    RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted));
     if (isDeleted)
       result.Insert(0, L"[DELETED]" WSTRING_PATH_SEPARATOR);
   }
@@ -798,7 +772,7 @@ int FindAltStreamColon_in_Path(const wchar_t *path)
     if (c == ':')
     {
       if (colonPos < 0)
-        colonPos = (int)i;
+        colonPos = i;
       continue;
     }
     if (c == WCHAR_PATH_SEPARATOR)
@@ -822,12 +796,12 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
   
   item.PathParts.Clear();
 
-  RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir))
+  RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir));
   item.MainIsDir = item.IsDir;
 
-  RINOK(GetItem_Path2(index, item.Path))
+  RINOK(GetItemPath2(index, item.Path));
 
-  #ifndef Z7_SFX
+  #ifndef _SFX
   UInt32 mainIndex = index;
   #endif
 
@@ -836,7 +810,7 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
   item.MainPath = item.Path;
   if (Ask_AltStream)
   {
-    RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream))
+    RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream));
   }
   
   bool needFindAltStream = false;
@@ -848,11 +822,11 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
     {
       UInt32 parentType = 0;
       UInt32 parentIndex;
-      RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType))
+      RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType));
       if (parentType == NParentType::kAltStream)
       {
         NCOM::CPropVariant prop;
-        RINOK(Archive->GetProperty(index, kpidName, &prop))
+        RINOK(Archive->GetProperty(index, kpidName, &prop));
         if (prop.vt == VT_BSTR && prop.bstrVal)
           item.AltStreamName.SetFromBstr(prop.bstrVal);
         else if (prop.vt != VT_EMPTY)
@@ -877,8 +851,8 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
         }
         else
         {
-          RINOK(GetItem_Path2(parentIndex, item.MainPath))
-          RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir))
+          RINOK(GetItemPath2(parentIndex, item.MainPath));
+          RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir));
         }
       }
     }
@@ -891,8 +865,8 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
     int colon = FindAltStreamColon_in_Path(item.Path);
     if (colon >= 0)
     {
-      item.MainPath.DeleteFrom((unsigned)colon);
-      item.AltStreamName = item.Path.Ptr((unsigned)(colon + 1));
+      item.MainPath.DeleteFrom(colon);
+      item.AltStreamName = item.Path.Ptr(colon + 1);
       item.MainIsDir = (colon == 0 || IsPathSepar(item.Path[(unsigned)colon - 1]));
       item.IsAltStream = true;
     }
@@ -900,10 +874,10 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
 
   #endif
   
-  #ifndef Z7_SFX
+  #ifndef _SFX
   if (item._use_baseParentFolder_mode)
   {
-    RINOK(GetItem_PathToParent(mainIndex, (unsigned)item._baseParentFolder, item.PathParts))
+    RINOK(GetItemPathToParent(mainIndex, item._baseParentFolder, item.PathParts));
     
     #ifdef SUPPORT_ALT_STREAMS
     if ((item.WriteToAltStreamIfColon || needFindAltStream) && !item.PathParts.IsEmpty())
@@ -914,10 +888,10 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
         colon = FindAltStreamColon_in_Path(s);
         if (colon >= 0)
         {
-          item.AltStreamName = s.Ptr((unsigned)(colon + 1));
+          item.AltStreamName = s.Ptr(colon + 1);
           item.MainIsDir = (colon == 0 || IsPathSepar(s[(unsigned)colon - 1]));
           item.IsAltStream = true;
-          s.DeleteFrom((unsigned)colon);
+          s.DeleteFrom(colon);
         }
       }
       if (colon == 0)
@@ -939,14 +913,14 @@ HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
   return S_OK;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &size, bool &defined)
 {
   NCOM::CPropVariant prop;
   defined = false;
   size = 0;
-  RINOK(archive->GetProperty(index, kpidSize, &prop))
+  RINOK(archive->GetProperty(index, kpidSize, &prop));
   switch (prop.vt)
   {
     case VT_UI1: size = prop.bVal; break;
@@ -962,12 +936,12 @@ static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &s
 
 #endif
 
-HRESULT CArc::GetItem_Size(UInt32 index, UInt64 &size, bool &defined) const
+HRESULT CArc::GetItemSize(UInt32 index, UInt64 &size, bool &defined) const
 {
   NCOM::CPropVariant prop;
   defined = false;
   size = 0;
-  RINOK(Archive->GetProperty(index, kpidSize, &prop))
+  RINOK(Archive->GetProperty(index, kpidSize, &prop));
   switch (prop.vt)
   {
     case VT_UI1: size = prop.bVal; break;
@@ -981,56 +955,28 @@ HRESULT CArc::GetItem_Size(UInt32 index, UInt64 &size, bool &defined) const
   return S_OK;
 }
 
-HRESULT CArc::GetItem_MTime(UInt32 index, CArcTime &at) const
+HRESULT CArc::GetItemMTime(UInt32 index, FILETIME &ft, bool &defined) const
 {
-  at.Clear();
   NCOM::CPropVariant prop;
-  RINOK(Archive->GetProperty(index, kpidMTime, &prop))
-  
+  defined = false;
+  ft.dwHighDateTime = ft.dwLowDateTime = 0;
+  RINOK(Archive->GetProperty(index, kpidMTime, &prop));
   if (prop.vt == VT_FILETIME)
   {
-    /*
-    // for debug
-    if (FILETIME_IsZero(prop.at) && MTime.Def)
-    {
-      at = MTime;
-      return S_OK;
-    }
-    */
-    at.Set_From_Prop(prop);
-    if (at.Prec == 0)
-    {
-      // (at.Prec == 0) before version 22.
-      // so kpidTimeType is required for that code
-      prop.Clear();
-      RINOK(Archive->GetProperty(index, kpidTimeType, &prop))
-      if (prop.vt == VT_UI4)
-      {
-        UInt32 val = prop.ulVal;
-        if (val == NFileTimeType::kWindows)
-          val = k_PropVar_TimePrec_100ns;
-        /*
-        else if (val > k_PropVar_TimePrec_1ns)
-        {
-          val = k_PropVar_TimePrec_100ns;
-          // val = k_PropVar_TimePrec_1ns;
-          // return E_FAIL; // for debug
-        }
-        */
-        at.Prec = (UInt16)val;
-      }
-    }
-    return S_OK;
+    ft = prop.filetime;
+    defined = true;
   }
-  
-  if (prop.vt != VT_EMPTY)
+  else if (prop.vt != VT_EMPTY)
     return E_FAIL;
-  if (MTime.Def)
-    at = MTime;
+  else if (MTimeDefined)
+  {
+    ft = MTime;
+    defined = true;
+  }
   return S_OK;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
 {
@@ -1040,43 +986,41 @@ static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
   return true;
 }
 
-
 static void MakeCheckOrder(CCodecs *codecs,
     CIntVector &orderIndices, unsigned numTypes, CIntVector &orderIndices2,
     const Byte *data, size_t dataSize)
 {
   for (unsigned i = 0; i < numTypes; i++)
   {
-    const int index = orderIndices[i];
+    int index = orderIndices[i];
     if (index < 0)
       continue;
     const CArcInfoEx &ai = codecs->Formats[(unsigned)index];
-    if (ai.SignatureOffset == 0)
+    if (ai.SignatureOffset != 0)
     {
-      if (ai.Signatures.IsEmpty())
-      {
-        if (dataSize != 0) // 21.04: no Signature means Empty Signature
-          continue;
-      }
-      else
+      orderIndices2.Add(index);
+      orderIndices[i] = -1;
+      continue;
+    }
+
+    const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
+    FOR_VECTOR (k, sigs)
+    {
+      const CByteBuffer &sig = sigs[k];
+      if (sig.Size() == 0 && dataSize == 0 ||
+          sig.Size() != 0 && sig.Size() <= dataSize &&
+          TestSignature(data, sig, sig.Size()))
       {
-        unsigned k;
-        const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
-        for (k = 0; k < sigs.Size(); k++)
-        {
-          const CByteBuffer &sig = sigs[k];
-          if (sig.Size() <= dataSize && TestSignature(data, sig, sig.Size()))
-            break;
-        }
-        if (k == sigs.Size())
-          continue;
+        orderIndices2.Add(index);
+        orderIndices[i] = -1;
+        break;
       }
     }
-    orderIndices2.Add(index);
-    orderIndices[i] = -1;
   }
 }
 
+#endif
+
 #ifdef UNDER_CE
   static const unsigned kNumHashBytes = 1;
   #define HASH_VAL(buf) ((buf)[0])
@@ -1086,6 +1030,9 @@ static void MakeCheckOrder(CCodecs *codecs,
   #define HASH_VAL(buf) GetUi16(buf)
 #endif
 
+
+#ifndef _SFX
+
 static bool IsExeExt(const UString &ext)
 {
   return ext.IsEqualTo_Ascii_NoCase("exe");
@@ -1113,7 +1060,7 @@ static bool IsPreArcFormat(const CArcInfoEx &ai)
 {
   if (ai.Flags_PreArc())
     return true;
-  return IsNameFromList(ai.Name, k_PreArcFormats, Z7_ARRAY_SIZE(k_PreArcFormats));
+  return IsNameFromList(ai.Name, k_PreArcFormats, ARRAY_SIZE(k_PreArcFormats));
 }
 
 static const char * const k_Formats_with_simple_signuature[] =
@@ -1135,46 +1082,44 @@ static bool IsNewStyleSignature(const CArcInfoEx &ai)
   // if (ai.Version >= 0x91F)
   if (ai.NewInterface)
     return true;
-  return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, Z7_ARRAY_SIZE(k_Formats_with_simple_signuature));
+  return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, ARRAY_SIZE(k_Formats_with_simple_signuature));
 }
 
-
-
-class CArchiveOpenCallback_Offset Z7_final:
+class CArchiveOpenCallback_Offset:
   public IArchiveOpenCallback,
   public IArchiveOpenVolumeCallback,
- #ifndef Z7_NO_CRYPTO
+  #ifndef _NO_CRYPTO
   public ICryptoGetTextPassword,
- #endif
+  #endif
   public CMyUnknownImp
 {
-  Z7_COM_QI_BEGIN2(IArchiveOpenCallback)
-  Z7_COM_QI_ENTRY(IArchiveOpenVolumeCallback)
- #ifndef Z7_NO_CRYPTO
-  Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
- #endif
-  Z7_COM_QI_END
-  Z7_COM_ADDREF_RELEASE
-
-  Z7_IFACE_COM7_IMP(IArchiveOpenCallback)
-  Z7_IFACE_COM7_IMP(IArchiveOpenVolumeCallback)
- #ifndef Z7_NO_CRYPTO
-  Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
- #endif
-
 public:
   CMyComPtr<IArchiveOpenCallback> Callback;
   CMyComPtr<IArchiveOpenVolumeCallback> OpenVolumeCallback;
   UInt64 Files;
   UInt64 Offset;
   
-  #ifndef Z7_NO_CRYPTO
+  #ifndef _NO_CRYPTO
   CMyComPtr<ICryptoGetTextPassword> GetTextPassword;
   #endif
+
+  MY_QUERYINTERFACE_BEGIN2(IArchiveOpenCallback)
+  MY_QUERYINTERFACE_ENTRY(IArchiveOpenVolumeCallback)
+  #ifndef _NO_CRYPTO
+  MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
+  #endif
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
+
+  INTERFACE_IArchiveOpenCallback(;)
+  INTERFACE_IArchiveOpenVolumeCallback(;)
+  #ifndef _NO_CRYPTO
+  STDMETHOD(CryptoGetTextPassword)(BSTR *password);
+  #endif
 };
 
-#ifndef Z7_NO_CRYPTO
-Z7_COM7F_IMF(CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password))
+#ifndef _NO_CRYPTO
+STDMETHODIMP CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password)
 {
   COM_TRY_BEGIN
   if (GetTextPassword)
@@ -1184,12 +1129,12 @@ Z7_COM7F_IMF(CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password))
 }
 #endif
 
-Z7_COM7F_IMF(CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *))
+STDMETHODIMP CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes))
+STDMETHODIMP CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes)
 {
   if (!Callback)
     return S_OK;
@@ -1199,7 +1144,7 @@ Z7_COM7F_IMF(CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UIn
   return Callback->SetCompleted(&Files, &value);
 }
 
-Z7_COM7F_IMF(CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value)
 {
   if (OpenVolumeCallback)
     return OpenVolumeCallback->GetProperty(propID, value);
@@ -1208,7 +1153,7 @@ Z7_COM7F_IMF(CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT
   // return E_NOTIMPL;
 }
 
-Z7_COM7F_IMF(CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream))
+STDMETHODIMP CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream)
 {
   if (OpenVolumeCallback)
     return OpenVolumeCallback->GetStream(name, inStream);
@@ -1252,7 +1197,7 @@ void CArcErrorInfo::ClearErrors()
 HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes)
 {
   // OkPhySize_Defined = false;
-  PhySize_Defined = false;
+  PhySizeDefined = false;
   PhySize = 0;
   Offset = 0;
   AvailPhySize = FileSize - startPos;
@@ -1260,49 +1205,49 @@ HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openR
   ErrorInfo.ClearErrors();
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop))
+    RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop));
     ErrorInfo.ErrorFlags = GetOpenArcErrorFlags(prop, &ErrorInfo.ErrorFlags_Defined);
   }
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop))
+    RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop));
     ErrorInfo.WarningFlags = GetOpenArcErrorFlags(prop);
   }
 
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidError, &prop))
+    RINOK(archive->GetArchiveProperty(kpidError, &prop));
     if (prop.vt != VT_EMPTY)
       ErrorInfo.ErrorMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown error");
   }
   
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidWarning, &prop))
+    RINOK(archive->GetArchiveProperty(kpidWarning, &prop));
     if (prop.vt != VT_EMPTY)
       ErrorInfo.WarningMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown warning");
   }
   
   if (openRes == S_OK || ErrorInfo.IsArc_After_NonOpen())
   {
-    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySize_Defined))
+    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySizeDefined));
     /*
     RINOK(Archive_GetArcProp_UInt(archive, kpidOkPhySize, OkPhySize, OkPhySize_Defined));
     if (!OkPhySize_Defined)
     {
-      OkPhySize_Defined = PhySize_Defined;
+      OkPhySize_Defined = PhySizeDefined;
       OkPhySize = PhySize;
     }
     */
 
     bool offsetDefined;
-    RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined))
+    RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined));
 
-    Int64 globalOffset = (Int64)startPos + Offset;
-    AvailPhySize = (UInt64)((Int64)FileSize - globalOffset);
-    if (PhySize_Defined)
+    Int64 globalOffset = startPos + Offset;
+    AvailPhySize = FileSize - globalOffset;
+    if (PhySizeDefined)
     {
-      UInt64 endPos = (UInt64)(globalOffset + (Int64)PhySize);
+      UInt64 endPos = globalOffset + PhySize;
       if (endPos < FileSize)
       {
         AvailPhySize = PhySize;
@@ -1318,12 +1263,11 @@ HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openR
 }
 
 /*
-static void PrintNumber(const char *s, int n)
+static PrintNumber(const char *s, int n)
 {
   char temp[100];
   sprintf(temp, "%s %d", s, n);
-  // OutputDebugStringA(temp);
-  printf(temp);
+  OutputDebugStringA(temp);
 }
 */
 
@@ -1332,31 +1276,31 @@ HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyCom
   // OutputDebugStringA("a1");
   // PrintNumber("formatIndex", formatIndex);
     
-  RINOK(op.codecs->CreateInArchive(formatIndex, archive))
+  RINOK(op.codecs->CreateInArchive(formatIndex, archive));
   // OutputDebugStringA("a2");
   if (!archive)
     return S_OK;
 
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   if (op.codecs->NeedSetLibCodecs)
   {
     const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
     if (ai.LibIndex >= 0 ?
-        !op.codecs->Libs[(unsigned)ai.LibIndex].SetCodecs :
+        !op.codecs->Libs[ai.LibIndex].SetCodecs :
         !op.codecs->Libs.IsEmpty())
     {
       CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
       archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
       if (setCompressCodecsInfo)
       {
-        RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs))
+        RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs));
       }
     }
   }
   #endif
   
   
-  #ifndef Z7_SFX
+  #ifndef _SFX
 
   const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
  
@@ -1386,14 +1330,14 @@ HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyCom
       }
     }
     */
-    RINOK(SetProperties(archive, *op.props))
+    RINOK(SetProperties(archive, *op.props));
   }
   
   #endif
   return S_OK;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NArchive::NParser::CParseItem &pi)
 {
@@ -1401,14 +1345,14 @@ static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NAr
   pi.FileTime_Defined = false;
   pi.ArcType = ai.Name;
   
-  RINOK(Archive_GetArcProp_Bool(archive, kpidIsNotArcType, pi.IsNotArcType))
+  RINOK(Archive_GetArcBoolProp(archive, kpidIsNotArcType, pi.IsNotArcType));
 
-  // RINOK(Archive_GetArcProp_Bool(archive, kpidIsSelfExe, pi.IsSelfExe));
+  // RINOK(Archive_GetArcBoolProp(archive, kpidIsSelfExe, pi.IsSelfExe));
   pi.IsSelfExe = ai.Flags_PreArc();
   
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidMTime, &prop))
+    RINOK(archive->GetArchiveProperty(kpidMTime, &prop));
     if (prop.vt == VT_FILETIME)
     {
       pi.FileTime_Defined = true;
@@ -1419,7 +1363,7 @@ static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NAr
   if (!pi.FileTime_Defined)
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidCTime, &prop))
+    RINOK(archive->GetArchiveProperty(kpidCTime, &prop));
     if (prop.vt == VT_FILETIME)
     {
       pi.FileTime_Defined = true;
@@ -1429,7 +1373,7 @@ static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NAr
   
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidName, &prop))
+    RINOK(archive->GetArchiveProperty(kpidName, &prop));
     if (prop.vt == VT_BSTR)
     {
       pi.Name.SetFromBstr(prop.bstrVal);
@@ -1437,7 +1381,7 @@ static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NAr
     }
     else
     {
-      RINOK(archive->GetArchiveProperty(kpidExtension, &prop))
+      RINOK(archive->GetArchiveProperty(kpidExtension, &prop));
       if (prop.vt == VT_BSTR)
         pi.Extension.SetFromBstr(prop.bstrVal);
     }
@@ -1445,14 +1389,14 @@ static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NAr
   
   {
     NCOM::CPropVariant prop;
-    RINOK(archive->GetArchiveProperty(kpidShortComment, &prop))
+    RINOK(archive->GetArchiveProperty(kpidShortComment, &prop));
     if (prop.vt == VT_BSTR)
       pi.Comment.SetFromBstr(prop.bstrVal);
   }
 
 
   UInt32 numItems;
-  RINOK(archive->GetNumberOfItems(&numItems))
+  RINOK(archive->GetNumberOfItems(&numItems));
   
   // pi.NumSubFiles = numItems;
   // RINOK(Archive_GetArcProp_UInt(archive, kpidUnpackSize, pi.UnpackSize, pi.UnpackSize_Defined));
@@ -1493,14 +1437,14 @@ HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
 {
   if (!op.stream)
     return S_OK;
-  RINOK(InStream_SeekSet(op.stream, offset))
+  RINOK(op.stream->Seek(offset, STREAM_SEEK_SET, NULL));
   const UInt32 kBufSize = 1 << 11;
   Byte buf[kBufSize];
   
   for (;;)
   {
     UInt32 processed = 0;
-    RINOK(op.stream->Read(buf, kBufSize, &processed))
+    RINOK(op.stream->Read(buf, kBufSize, &processed));
     if (processed == 0)
     {
       // ErrorInfo.NonZerosTail = false;
@@ -1519,21 +1463,21 @@ HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
   }
 }
 
+#ifndef _SFX
 
-
-#ifndef Z7_SFX
-
-Z7_CLASS_IMP_COM_2(
-  CExtractCallback_To_OpenCallback
-  , IArchiveExtractCallback
-  , ICompressProgressInfo
-)
-  Z7_IFACE_COM7_IMP(IProgress)
+class CExtractCallback_To_OpenCallback:
+  public IArchiveExtractCallback,
+  public ICompressProgressInfo,
+  public CMyUnknownImp
+{
 public:
   CMyComPtr<IArchiveOpenCallback> Callback;
   UInt64 Files;
   UInt64 Offset;
 
+  MY_UNKNOWN_IMP2(IArchiveExtractCallback, ICompressProgressInfo)
+  INTERFACE_IArchiveExtractCallback(;)
+  STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
   void Init(IArchiveOpenCallback *callback)
   {
     Callback = callback;
@@ -1542,17 +1486,17 @@ public:
   }
 };
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
 {
   if (Callback)
   {
@@ -1564,23 +1508,22 @@ Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize
   return S_OK;
 }
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */)
 {
-  *outStream = NULL;
+  *outStream = 0;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */)
 {
   return S_OK;
 }
 
-Z7_COM7F_IMF(CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */))
+STDMETHODIMP CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */)
 {
   return S_OK;
 }
 
-
 static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
     IInStream *stream, const UInt64 *maxCheckStartPosition,
     IArchiveOpenCallback *openCallback,
@@ -1589,48 +1532,37 @@ static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
   /*
   if (needPhySize)
   {
-    Z7_DECL_CMyComPtr_QI_FROM(
-        IArchiveOpen2,
-        open2, archive)
+    CMyComPtr<IArchiveOpen2> open2;
+    archive->QueryInterface(IID_IArchiveOpen2, (void **)&open2);
     if (open2)
       return open2->ArcOpen2(stream, kOpenFlags_RealPhySize, openCallback);
   }
   */
-  RINOK(archive->Open(stream, maxCheckStartPosition, openCallback))
+  RINOK(archive->Open(stream, maxCheckStartPosition, openCallback));
   if (needPhySize)
   {
     bool phySize_Defined = false;
     UInt64 phySize = 0;
-    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined))
+    RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined));
     if (phySize_Defined)
       return S_OK;
 
-    bool phySizeCantBeDetected = false;
-    RINOK(Archive_GetArcProp_Bool(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected))
+    bool phySizeCantBeDetected = false;;
+    RINOK(Archive_GetArcBoolProp(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected));
 
     if (!phySizeCantBeDetected)
     {
-      PRF(printf("\n-- !phySize_Defined after Open, call archive->Extract()"));
-      // It's for bzip2/gz and some xz archives, where Open operation doesn't know phySize.
-      // But the Handler will know phySize after full archive testing.
-      RINOK(archive->Extract(NULL, (UInt32)(Int32)-1, BoolToInt(true), extractCallback))
-      PRF(printf("\n-- OK"));
+      RINOK(archive->Extract(0, (UInt32)(Int32)-1, BoolToInt(true), extractCallback));
     }
   }
   return S_OK;
 }
 
-
-
 static int FindFormatForArchiveType(CCodecs *codecs, CIntVector orderIndices, const char *name)
 {
   FOR_VECTOR (i, orderIndices)
-  {
-    int oi = orderIndices[i];
-    if (oi >= 0)
-      if (StringsAreEqualNoCase_Ascii(codecs->Formats[(unsigned)oi].Name, name))
-        return (int)i;
-  }
+    if (StringsAreEqualNoCase_Ascii(codecs->Formats[orderIndices[i]].Name, name))
+      return i;
   return -1;
 }
 
@@ -1656,15 +1588,15 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
   const UString fileName = ExtractFileNameFromPath(Path);
   UString extension;
   {
-    const int dotPos = fileName.ReverseFind_Dot();
+    int dotPos = fileName.ReverseFind_Dot();
     if (dotPos >= 0)
-      extension = fileName.Ptr((unsigned)(dotPos + 1));
+      extension = fileName.Ptr(dotPos + 1);
   }
   
   CIntVector orderIndices;
   
   bool searchMarkerInHandler = false;
-  #ifdef Z7_SFX
+  #ifdef _SFX
     searchMarkerInHandler = true;
   #endif
 
@@ -1674,27 +1606,22 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       isMainFormatArr[i] = false;
   }
 
-  const UInt64 maxStartOffset =
+  UInt64 maxStartOffset =
       op.openType.MaxStartOffset_Defined ?
       op.openType.MaxStartOffset :
       kMaxCheckStartPosition;
 
-  #ifndef Z7_SFX
+  #ifndef _SFX
   bool isUnknownExt = false;
   #endif
 
-  #ifndef Z7_SFX
   bool isForced = false;
-  #endif
-
   unsigned numMainTypes = 0;
-  const int formatIndex = op.openType.FormatIndex;
+  int formatIndex = op.openType.FormatIndex;
 
   if (formatIndex >= 0)
   {
-    #ifndef Z7_SFX
     isForced = true;
-    #endif
     orderIndices.Add(formatIndex);
     numMainTypes = 1;
     isMainFormatArr[(unsigned)formatIndex] = true;
@@ -1704,12 +1631,12 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
   else
   {
     unsigned numFinded = 0;
-    #ifndef Z7_SFX
+    #ifndef _SFX
     bool isPrearcExt = false;
     #endif
     
     {
-      #ifndef Z7_SFX
+      #ifndef _SFX
       
       bool isZip = false;
       bool isRar = false;
@@ -1731,12 +1658,10 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           isNumber = true;
         }
         if (isNumber)
-        {
           if (c == 'z' || c == 'Z')
             isZip = true;
           else
             isRar = true;
-        }
       }
       
       #endif
@@ -1746,29 +1671,29 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         const CArcInfoEx &ai = op.codecs->Formats[i];
 
         if (IgnoreSplit || !op.openType.CanReturnArc)
-          if (ai.Is_Split())
+          if (ai.IsSplit())
             continue;
-        if (op.excludedFormats->FindInSorted((int)i) >= 0)
+        if (op.excludedFormats->FindInSorted(i) >= 0)
           continue;
 
-        #ifndef Z7_SFX
+        #ifndef _SFX
         if (IsPreArcFormat(ai))
           isPrearcExt = true;
         #endif
 
         if (ai.FindExtension(extension) >= 0
-            #ifndef Z7_SFX
-            || (isZip && ai.Is_Zip())
-            || (isRar && ai.Is_Rar())
+            #ifndef _SFX
+            || isZip && StringsAreEqualNoCase_Ascii(ai.Name, "zip")
+            || isRar && StringsAreEqualNoCase_Ascii(ai.Name, "rar")
             #endif
             )
         {
           // PrintNumber("orderIndices.Insert", i);
-          orderIndices.Insert(numFinded++, (int)i);
+          orderIndices.Insert(numFinded++, i);
           isMainFormatArr[i] = true;
         }
         else
-          orderIndices.Add((int)i);
+          orderIndices.Add(i);
       }
     }
   
@@ -1788,11 +1713,11 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
     }
     */
 
-    #ifndef Z7_SFX
+    #ifndef _SFX
 
       if (op.stream && orderIndices.Size() >= 2)
       {
-        RINOK(InStream_SeekToBegin(op.stream))
+        RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
         CByteBuffer byteBuffer;
         CIntVector orderIndices2;
         if (numFinded == 0 || IsExeExt(extension))
@@ -1801,21 +1726,21 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         }
         else if (extension.IsEqualTo("000") || extension.IsEqualTo("001"))
         {
-          const int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
+          int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
           if (i >= 0)
           {
             const size_t kBufSize = (1 << 10);
             byteBuffer.Alloc(kBufSize);
             size_t processedSize = kBufSize;
-            RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+            RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
             if (processedSize >= 16)
             {
               const Byte *buf = byteBuffer;
               const Byte kRarHeader[] = { 0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
               if (TestSignature(buf, kRarHeader, 7) && buf[9] == 0x73 && (buf[10] & 1) != 0)
               {
-                orderIndices2.Add(orderIndices[(unsigned)i]);
-                orderIndices[(unsigned)i] = -1;
+                orderIndices2.Add(orderIndices[i]);
+                orderIndices[i] = -1;
                 if (i >= (int)numFinded)
                   numFinded++;
               }
@@ -1827,33 +1752,17 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           const size_t kBufSize = (1 << 10);
           byteBuffer.Alloc(kBufSize);
           size_t processedSize = kBufSize;
-          RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+          RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
           if (processedSize == 0)
             return S_FALSE;
           
           /*
           check type order:
-            0) matched_extension && Backward
-            1) matched_extension && (no_signuature || SignatureOffset != 0)
-            2) matched_extension && (matched_signature)
+            1) matched extension, no signuature
+            2) matched extension, matched signuature
             // 3) no signuature
             // 4) matched signuature
           */
-          // we move index from orderIndices to orderIndices2 for priority handlers.
-
-          for (unsigned i = 0; i < numFinded; i++)
-          {
-            const int index = orderIndices[i];
-            if (index < 0)
-              continue;
-            const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
-            if (ai.Flags_BackwardOpen())
-            {
-              // backward doesn't need start signatures
-              orderIndices2.Add(index);
-              orderIndices[i] = -1;
-            }
-          }
 
           MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, NULL, 0);
           MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, byteBuffer, processedSize);
@@ -1863,7 +1772,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       
         FOR_VECTOR (i, orderIndices)
         {
-          const int val = orderIndices[i];
+          int val = orderIndices[i];
           if (val != -1)
             orderIndices2.Add(val);
         }
@@ -1872,21 +1781,21 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       
       if (orderIndices.Size() >= 2)
       {
-        const int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
-        const int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
+        int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
+        int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
         if (iUdf > iIso && iIso >= 0)
         {
-          const int isoIndex = orderIndices[(unsigned)iIso];
-          const int udfIndex = orderIndices[(unsigned)iUdf];
-          orderIndices[(unsigned)iUdf] = isoIndex;
-          orderIndices[(unsigned)iIso] = udfIndex;
+          int isoIndex = orderIndices[iIso];
+          int udfIndex = orderIndices[iUdf];
+          orderIndices[iUdf] = isoIndex;
+          orderIndices[iIso] = udfIndex;
         }
       }
 
       numMainTypes = numFinded;
       isUnknownExt = (numMainTypes == 0) || isPrearcExt;
 
-    #else // Z7_SFX
+    #else // _SFX
 
       numMainTypes = orderIndices.Size();
 
@@ -1900,12 +1809,13 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
   UInt64 fileSize = 0;
   if (op.stream)
   {
-    RINOK(InStream_GetSize_SeekToBegin(op.stream, fileSize))
+    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
+    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
   }
   FileSize = fileSize;
 
 
-  #ifndef Z7_SFX
+  #ifndef _SFX
 
   CBoolArr skipFrontalFormat(op.codecs->Formats.Size());
   {
@@ -1932,18 +1842,15 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
     for (unsigned i = 0; i < numCheckTypes; i++)
     {
       FormatIndex = orderIndices[i];
-
-      // orderIndices[] item cannot be negative here
       
       bool exactOnly = false;
 
-      #ifndef Z7_SFX
+      #ifndef _SFX
     
-      const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
       // OutputDebugStringW(ai.Name);
       if (i >= numMainTypes)
       {
-        // here we allow mismatched extension only for backward handlers
         if (!ai.Flags_BackwardOpen()
             // && !ai.Flags_PureStartOpen()
             )
@@ -1955,16 +1862,16 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       
       // Some handlers do not set total bytes. So we set it here
       if (op.callback)
-        RINOK(op.callback->SetTotal(NULL, &fileSize))
+        RINOK(op.callback->SetTotal(NULL, &fileSize));
 
       if (op.stream)
       {
-        RINOK(InStream_SeekToBegin(op.stream))
+        RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
       }
       
       CMyComPtr<IInArchive> archive;
       
-      RINOK(PrepareToOpen(op, (unsigned)FormatIndex, archive))
+      RINOK(PrepareToOpen(op, FormatIndex, archive));
       if (!archive)
         continue;
       
@@ -1983,13 +1890,13 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         result = openSeq->OpenSeq(op.seqStream);
       }
       
-      RINOK(ReadBasicProps(archive, 0, result))
+      RINOK(ReadBasicProps(archive, 0, result));
       
       if (result == S_FALSE)
       {
         bool isArc = ErrorInfo.IsArc_After_NonOpen();
 
-        #ifndef Z7_SFX
+        #ifndef _SFX
         // if it's archive, we allow another open attempt for parser
         if (!mode.CanReturnParser || !isArc)
           skipFrontalFormat[(unsigned)FormatIndex] = true;
@@ -2009,7 +1916,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
             // if (formatIndex < 0 && !searchMarkerInHandler)
             {
               // if bad archive was detected, we don't need additional open attempts
-              #ifndef Z7_SFX
+              #ifndef _SFX
               if (!IsPreArcFormat(ai) /* || !mode.SkipSfxStub */)
               #endif
                 return S_FALSE;
@@ -2018,7 +1925,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         }
         
         /*
-        #ifndef Z7_SFX
+        #ifndef _SFX
         if (IsExeExt(extension) || ai.Flags_PreArc())
         {
         // openOnlyFullArc = false;
@@ -2031,9 +1938,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         continue;
       }
       
-      RINOK(result)
+      RINOK(result);
       
-      #ifndef Z7_SFX
+      #ifndef _SFX
 
       bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
       const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
@@ -2041,7 +1948,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       bool thereIsTail = ErrorInfo.ThereIsTail;
       if (thereIsTail && mode.ZerosTailIsAllowed)
       {
-        RINOK(CheckZerosTail(op, (UInt64)(Offset + (Int64)PhySize)))
+        RINOK(CheckZerosTail(op, Offset + PhySize));
         if (ErrorInfo.IgnoreTail)
           thereIsTail = false;
       }
@@ -2095,7 +2002,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
 
   
 
-  #ifndef Z7_SFX
+  #ifndef _SFX
 
   if (!op.stream)
     return S_FALSE;
@@ -2140,9 +2047,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         endOfFile = true;
       }
       byteBuffer.Alloc(bufSize);
-      RINOK(InStream_SeekToBegin(op.stream))
+      RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
       processedSize = bufSize;
-      RINOK(ReadStream(op.stream, byteBuffer, &processedSize))
+      RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
       if (processedSize == 0)
         return S_FALSE;
       if (processedSize < bufSize)
@@ -2156,22 +2063,16 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
 
     for (i = 0; i < orderIndices.Size(); i++)
     {
-      // orderIndices[] item cannot be negative here
-      unsigned form = (unsigned)orderIndices[i];
+      unsigned form = orderIndices[i];
       if (skipFrontalFormat[form])
         continue;
-      
       const CArcInfoEx &ai = op.codecs->Formats[form];
-      
-      if (ai.Is_Split())
+      if (ai.IsSplit())
       {
-        splitIndex = (int)form;
+        splitIndex = form;
         continue;
       }
 
-      if (ai.Flags_ByExtOnlyOpen())
-        continue;
-
       if (ai.IsArcFunc)
       {
         UInt32 isArcRes = ai.IsArcFunc(byteBuffer, processedSize);
@@ -2184,7 +2085,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         continue;
       }
 
-      const bool isNewStyleSignature = IsNewStyleSignature(ai);
+      bool isNewStyleSignature = IsNewStyleSignature(ai);
       bool needCheck = !isNewStyleSignature
           || ai.Signatures.IsEmpty()
           || ai.Flags_PureStartOpen()
@@ -2197,12 +2098,13 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         for (k = 0; k < ai.Signatures.Size(); k++)
         {
           const CByteBuffer &sig = ai.Signatures[k];
-          if (processedSize < ai.SignatureOffset + sig.Size())
+          UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
+          if (processedSize < signatureEnd)
           {
             if (!endOfFile)
               needCheck = true;
           }
-          else if (TestSignature(sig, byteBuffer + ai.SignatureOffset, sig.Size()))
+          else if (memcmp(sig, byteBuffer + ai.SignatureOffset, sig.Size()) == 0)
             break;
         }
         if (k != ai.Signatures.Size())
@@ -2216,20 +2118,20 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
     }
 
     if (splitIndex >= 0)
-      sortedFormats.Insert(0, (unsigned)splitIndex);
+      sortedFormats.Insert(0, splitIndex);
 
     for (i = 0; i < sortedFormats.Size(); i++)
     {
-      FormatIndex = (int)sortedFormats[i];
-      const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+      FormatIndex = sortedFormats[i];
+      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
 
       if (op.callback)
-        RINOK(op.callback->SetTotal(NULL, &fileSize))
+        RINOK(op.callback->SetTotal(NULL, &fileSize));
 
-      RINOK(InStream_SeekToBegin(op.stream))
+      RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
 
       CMyComPtr<IInArchive> archive;
-      RINOK(PrepareToOpen(op, (unsigned)FormatIndex, archive))
+      RINOK(PrepareToOpen(op, FormatIndex, archive));
       if (!archive)
         continue;
       
@@ -2242,10 +2144,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           result = archive->Open(op.stream, &searchLimit, op.callback);
         else
         */
-        // if (!CanReturnArc), it's ParserMode, and we need phy size
-        result = OpenArchiveSpec(archive,
-            !mode.CanReturnArc, // needPhySize
-            op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
+        result = OpenArchiveSpec(archive, !mode.CanReturnArc, op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
       }
       
       if (result == S_FALSE)
@@ -2255,9 +2154,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         // printf("  OpenForSize Error");
         continue;
       }
-      RINOK(result)
+      RINOK(result);
 
-      RINOK(ReadBasicProps(archive, 0, result))
+      RINOK(ReadBasicProps(archive, 0, result));
 
       if (Offset > 0)
       {
@@ -2267,12 +2166,12 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       }
 
       NArchive::NParser::CParseItem pi;
-      pi.Offset = (UInt64)Offset;
+      pi.Offset = Offset;
       pi.Size = AvailPhySize;
       
       // bool needScan = false;
 
-      if (!PhySize_Defined)
+      if (!PhySizeDefined)
       {
         // it's for Z format
         pi.LenIsUnknown = true;
@@ -2294,7 +2193,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
 
       if (mode.CanReturnArc)
       {
-        const bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
+        bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
         const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
         bool openCur = false;
 
@@ -2304,7 +2203,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         {
           if (mode.ZerosTailIsAllowed)
           {
-            RINOK(CheckZerosTail(op, (UInt64)(Offset + (Int64)PhySize)))
+            RINOK(CheckZerosTail(op, Offset + PhySize));
             if (ErrorInfo.IgnoreTail)
               openCur = true;
           }
@@ -2344,7 +2243,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         continue;
 
       // printf("\nAdd offset = %d", (int)pi.Offset);
-      RINOK(ReadParseItemProps(archive, ai, pi))
+      RINOK(ReadParseItemProps(archive, ai, pi));
       handlerSpec->AddItem(pi);
     }
   }
@@ -2400,8 +2299,6 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       if (index < 0)
         continue;
       const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
-      if (ai.Flags_ByExtOnlyOpen())
-        continue;
       bool isDifficult = false;
       // if (ai.Version < 0x91F) // we don't use parser with old DLL (before 9.31)
       if (!ai.NewInterface)
@@ -2432,7 +2329,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       }
       if (isDifficult)
       {
-        difficultFormats.Add((unsigned)index);
+        difficultFormats.Add(index);
         difficultBools[(unsigned)index] = true;
       }
     }
@@ -2443,7 +2340,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       // canReturnTailArc = true;
     }
     
-    RINOK(InStream_SeekToBegin(op.stream))
+    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
 
     CLimitedCachedInStream *limitedStreamSpec = new CLimitedCachedInStream;
     CMyComPtr<IInStream> limitedStream = limitedStreamSpec;
@@ -2457,13 +2354,13 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
       openCallback_Offset = openCallback_Offset_Spec;
       openCallback_Offset_Spec->Callback = op.callback;
       openCallback_Offset_Spec->Callback.QueryInterface(IID_IArchiveOpenVolumeCallback, &openCallback_Offset_Spec->OpenVolumeCallback);
-      #ifndef Z7_NO_CRYPTO
+      #ifndef _NO_CRYPTO
       openCallback_Offset_Spec->Callback.QueryInterface(IID_ICryptoGetTextPassword, &openCallback_Offset_Spec->GetTextPassword);
       #endif
     }
 
     if (op.callback)
-      RINOK(op.callback->SetTotal(NULL, &fileSize))
+      RINOK(op.callback->SetTotal(NULL, &fileSize));
   
     CByteBuffer &byteBuffer = limitedStreamSpec->Buffer;
     byteBuffer.Alloc(kBufSize);
@@ -2501,8 +2398,8 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           size_t processedSize = kBufSize - bytesInBuf;
           // printf("\nRead ask = %d", (unsigned)processedSize);
           UInt64 seekPos = bufPhyPos + bytesInBuf;
-          RINOK(InStream_SeekSet(op.stream, bufPhyPos + bytesInBuf))
-          RINOK(ReadStream(op.stream, byteBuffer.NonConstData() + bytesInBuf, &processedSize))
+          RINOK(op.stream->Seek(bufPhyPos + bytesInBuf, STREAM_SEEK_SET, NULL));
+          RINOK(ReadStream(op.stream, byteBuffer + bytesInBuf, &processedSize));
           // printf("   processed = %d", (unsigned)processedSize);
           if (processedSize == 0)
           {
@@ -2524,7 +2421,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           {
             size_t keepSize = (size_t)(kBeforeSize - skipSize);
             // printf("\nmemmove skip = %d", (int)keepSize);
-            memmove(byteBuffer, byteBuffer.ConstData() + bytesInBuf - keepSize, keepSize);
+            memmove(byteBuffer, byteBuffer + bytesInBuf - keepSize, keepSize);
             bytesInBuf = keepSize;
             bufPhyPos = pos - keepSize;
             continue;
@@ -2540,7 +2437,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         {
           size_t beg = (size_t)posInBuf - kBeforeSize;
           // printf("\nmemmove for after beg = %d", (int)beg);
-          memmove(byteBuffer, byteBuffer.ConstData() + beg, bytesInBuf - beg);
+          memmove(byteBuffer, byteBuffer + beg, bytesInBuf - beg);
           bufPhyPos += beg;
           bytesInBuf -= beg;
           continue;
@@ -2560,7 +2457,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
  
         if (pos >= callbackPrev + (1 << 23))
         {
-          RINOK(openCallback_Offset->SetCompleted(NULL, NULL))
+          RINOK(openCallback_Offset_Spec->SetCompleted(NULL, NULL));
           callbackPrev = pos;
         }
       }
@@ -2574,7 +2471,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         }
       }
 
-      const size_t availSize = bytesInBuf - (size_t)posInBuf;
+      size_t availSize = bytesInBuf - (size_t)posInBuf;
       if (availSize < kNumHashBytes)
         break;
       size_t scanSize = availSize -
@@ -2598,14 +2495,14 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
 
       scanSize++;
 
-      const Byte *buf = byteBuffer.ConstData() + (size_t)posInBuf;
+      const Byte *buf = byteBuffer + (size_t)posInBuf;
       const Byte *bufLimit = buf + scanSize;
       size_t ppp = 0;
       
       if (!needCheckStartOpen)
       {
         for (; buf < bufLimit && hash[HASH_VAL(buf)] == 0xFF; buf++);
-        ppp = (size_t)(buf - (byteBuffer.ConstData() + (size_t)posInBuf));
+        ppp = buf - (byteBuffer + (size_t)posInBuf);
         pos += ppp;
         if (buf == bufLimit)
           continue;
@@ -2683,10 +2580,10 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         
         if (ai.IsArcFunc && startArcPos >= bufPhyPos)
         {
-          const size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
+          size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
           if (offsetInBuf < bytesInBuf)
           {
-            const UInt32 isArcRes = ai.IsArcFunc(byteBuffer.ConstData() + offsetInBuf, bytesInBuf - offsetInBuf);
+            UInt32 isArcRes = ai.IsArcFunc(byteBuffer + offsetInBuf, bytesInBuf - offsetInBuf);
             if (isArcRes == k_IsArc_Res_NO)
               continue;
             if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
@@ -2702,30 +2599,34 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           // printf("\nIsArc OK: %S", (const wchar_t *)ai.Name);
         }
         
+        /*
+        if (pos == 67109888)
+          pos = pos;
+        */
         PRF(printf("\npos = %9I64d : %S", pos, (const wchar_t *)ai.Name));
 
-        const bool isMainFormat = isMainFormatArr[index];
+        bool isMainFormat = isMainFormatArr[index];
         const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
         
         CMyComPtr<IInArchive> archive;
-        RINOK(PrepareToOpen(op, index, archive))
+        RINOK(PrepareToOpen(op, index, archive));
         if (!archive)
           return E_FAIL;
         
         // OutputDebugStringW(ai.Name);
         
-        const UInt64 rem = fileSize - startArcPos;
+        UInt64 rem = fileSize - startArcPos;
         
         UInt64 arcStreamOffset = 0;
 
         if (ai.Flags_UseGlobalOffset())
         {
-          RINOK(limitedStreamSpec->InitAndSeek(0, fileSize))
-          RINOK(InStream_SeekSet(limitedStream, startArcPos))
+          limitedStreamSpec->InitAndSeek(0, fileSize);
+          limitedStream->Seek(startArcPos, STREAM_SEEK_SET, NULL);
         }
         else
         {
-          RINOK(limitedStreamSpec->InitAndSeek(startArcPos, rem))
+          limitedStreamSpec->InitAndSeek(startArcPos, rem);
           arcStreamOffset = startArcPos;
         }
         
@@ -2741,42 +2642,33 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         extractCallback_To_OpenCallback_Spec->Files = 0;
         extractCallback_To_OpenCallback_Spec->Offset = startArcPos;
 
-        HRESULT result = OpenArchiveSpec(archive,
-            true, // needPhySize
-            limitedStream, &maxCheckStartPosition,
+        HRESULT result = OpenArchiveSpec(archive, true, limitedStream, &maxCheckStartPosition,
             useOffsetCallback ? (IArchiveOpenCallback *)openCallback_Offset : (IArchiveOpenCallback *)op.callback,
             extractCallback_To_OpenCallback);
 
-        RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result))
+        RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result));
 
         bool isOpen = false;
-      
         if (result == S_FALSE)
         {
           if (!mode.CanReturnParser)
           {
             if (formatIndex < 0 && ErrorInfo.IsArc_After_NonOpen())
             {
-              ErrorInfo.ErrorFormatIndex = (int)index;
+              ErrorInfo.ErrorFormatIndex = index;
               NonOpen_ErrorInfo = ErrorInfo;
               // if archive was detected, we don't need additional open attempts
               return S_FALSE;
             }
             continue;
           }
-          if (!ErrorInfo.IsArc_After_NonOpen() || !PhySize_Defined || PhySize == 0)
+          if (!ErrorInfo.IsArc_After_NonOpen() || !PhySizeDefined || PhySize == 0)
             continue;
         }
         else
         {
-          if (PhySize_Defined && PhySize == 0)
-          {
-            PRF(printf("  phySize_Defined && PhySize == 0 "));
-            // we skip that epmty archive case with unusual unexpected (PhySize == 0) from Code function.
-            continue;
-          }
           isOpen = true;
-          RINOK(result)
+          RINOK(result);
           PRF(printf("  OK "));
         }
 
@@ -2788,14 +2680,13 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         pi.Offset = startArcPos;
 
         if (ai.Flags_UseGlobalOffset())
-          pi.Offset = (UInt64)Offset;
+          pi.Offset = Offset;
         else if (Offset != 0)
           return E_FAIL;
-
-        const UInt64 arcRem = FileSize - pi.Offset;
+        UInt64 arcRem = FileSize - pi.Offset;
         UInt64 phySize = arcRem;
-        const bool phySize_Defined = PhySize_Defined;
-        if (phySize_Defined)
+        bool phySizeDefined = PhySizeDefined;
+        if (phySizeDefined)
         {
           if (pi.Offset + PhySize > FileSize)
           {
@@ -2821,9 +2712,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         bool needScan = false;
 
  
-        if (isOpen && !phySize_Defined)
+        if (isOpen && !phySizeDefined)
         {
-          // it's for Z format, or bzip2,gz,xz with phySize that was not detected
+          // it's for Z format
           pi.LenIsUnknown = true;
           needScan = true;
           phySize = arcRem;
@@ -2840,7 +2731,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
 
         /*
         if (needSkipFullArc)
-          if (pi.Offset == 0 && phySize_Defined && pi.Size >= fileSize)
+          if (pi.Offset == 0 && phySizeDefined && pi.Size >= fileSize)
             continue;
         */
         if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
@@ -2866,9 +2757,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           pos = pi.Offset + pi.Size;
 
        
-        RINOK(ReadParseItemProps(archive, ai, pi))
+        RINOK(ReadParseItemProps(archive, ai, pi));
 
-        if (pi.Offset < startArcPos && !mode.EachPos /* && phySize_Defined */)
+        if (pi.Offset < startArcPos && !mode.EachPos /* && phySizeDefined */)
         {
           /* It's for DMG format.
           This code deletes all previous items that are included to current item */
@@ -2887,7 +2778,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         }
         
 
-        if (isOpen && mode.CanReturnArc && phySize_Defined)
+        if (isOpen && mode.CanReturnArc && phySizeDefined)
         {
           // if (pi.Offset + pi.Size >= fileSize)
           bool openCur = false;
@@ -2895,7 +2786,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           bool thereIsTail = ErrorInfo.ThereIsTail;
           if (thereIsTail && mode.ZerosTailIsAllowed)
           {
-            RINOK(CheckZerosTail(op, (UInt64)((Int64)arcStreamOffset + Offset + (Int64)PhySize)))
+            RINOK(CheckZerosTail(op, arcStreamOffset + Offset + PhySize));
             if (ErrorInfo.IgnoreTail)
               thereIsTail = false;
           }
@@ -2903,12 +2794,10 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           if (pi.Offset != 0)
           {
             if (!pi.IsNotArcType)
-            {
               if (thereIsTail)
                 openCur = specFlags.CanReturnMid;
               else
                 openCur = specFlags.CanReturnTail;
-            }
           }
           else
           {
@@ -2916,11 +2805,11 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
               openCur = true;
             else
               openCur = specFlags.CanReturnFrontal;
+              
 
             if (formatIndex >= -2)
               openCur = true;
           }
-
           if (formatIndex < 0 && pi.IsSelfExe /* && mode.SkipSfxStub */)
             openCur = false;
 
@@ -2947,7 +2836,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
           {
             InStream = op.stream;
             Archive = archive;
-            FormatIndex = (int)index;
+            FormatIndex = index;
             ArcStreamOffset = arcStreamOffset;
             return S_OK;
           }
@@ -2961,7 +2850,7 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
         }
         */
 
-        pi.FormatIndex = (int)index;
+        pi.FormatIndex = index;
 
         // printf("\nAdd offset = %d", (int)pi.Offset);
         handlerSpec->AddItem(pi);
@@ -3016,12 +2905,9 @@ HRESULT CArc::OpenStream2(const COpenOptions &op)
   return S_OK;
 }
 
-
-
-
 HRESULT CArc::OpenStream(const COpenOptions &op)
 {
-  RINOK(OpenStream2(op))
+  RINOK(OpenStream2(op));
   // PrintNumber("op.formatIndex 3", op.formatIndex);
 
   if (Archive)
@@ -3031,25 +2917,25 @@ HRESULT CArc::OpenStream(const COpenOptions &op)
     Archive->QueryInterface(IID_IArchiveGetRawProps, (void **)&GetRawProps);
     Archive->QueryInterface(IID_IArchiveGetRootProps, (void **)&GetRootProps);
 
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidIsTree, IsTree))
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidIsDeleted, Ask_Deleted))
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidIsAltStream, Ask_AltStream))
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidIsAux, Ask_Aux))
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidINode, Ask_INode))
-    RINOK(Archive_GetArcProp_Bool(Archive, kpidReadOnly, IsReadOnly))
+    RINOK(Archive_GetArcBoolProp(Archive, kpidIsTree, IsTree));
+    RINOK(Archive_GetArcBoolProp(Archive, kpidIsDeleted, Ask_Deleted));
+    RINOK(Archive_GetArcBoolProp(Archive, kpidIsAltStream, Ask_AltStream));
+    RINOK(Archive_GetArcBoolProp(Archive, kpidIsAux, Ask_Aux));
+    RINOK(Archive_GetArcBoolProp(Archive, kpidINode, Ask_INode));
+    RINOK(Archive_GetArcBoolProp(Archive, kpidReadOnly, IsReadOnly));
 
     const UString fileName = ExtractFileNameFromPath(Path);
     UString extension;
     {
       int dotPos = fileName.ReverseFind_Dot();
       if (dotPos >= 0)
-        extension = fileName.Ptr((unsigned)(dotPos + 1));
+        extension = fileName.Ptr(dotPos + 1);
     }
     
     DefaultName.Empty();
     if (FormatIndex >= 0)
     {
-      const CArcInfoEx &ai = op.codecs->Formats[(unsigned)FormatIndex];
+      const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
       if (ai.Exts.Size() == 0)
         DefaultName = GetDefaultName2(fileName, UString(), UString());
       else
@@ -3057,7 +2943,7 @@ HRESULT CArc::OpenStream(const COpenOptions &op)
         int subExtIndex = ai.FindExtension(extension);
         if (subExtIndex < 0)
           subExtIndex = 0;
-        const CArcExtInfo &extInfo = ai.Exts[(unsigned)subExtIndex];
+        const CArcExtInfo &extInfo = ai.Exts[subExtIndex];
         DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
       }
     }
@@ -3066,7 +2952,7 @@ HRESULT CArc::OpenStream(const COpenOptions &op)
   return S_OK;
 }
 
-#ifdef Z7_SFX
+#ifdef _SFX
 
 #ifdef _WIN32
   #define k_ExeExt ".exe"
@@ -3086,12 +2972,7 @@ HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
   
   if (op.stdInMode)
   {
-#if 1
     seqStream = new CStdInFileStream;
-#else
-    if (!CreateStdInStream(seqStream))
-      return GetLastError_noZero_HRESULT();
-#endif
     op.seqStream = seqStream;
   }
   else if (!op.stream)
@@ -3100,9 +2981,11 @@ HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
     fileStream = fileStreamSpec;
     Path = filePath;
     if (!fileStreamSpec->Open(us2fs(Path)))
-      return GetLastError_noZero_HRESULT();
+    {
+      return GetLastError();
+    }
     op.stream = fileStream;
-    #ifdef Z7_SFX
+    #ifdef _SFX
     IgnoreSplit = true;
     #endif
   }
@@ -3111,7 +2994,7 @@ HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
   if (callback)
   {
     UInt64 fileSize;
-    RINOK(InStream_GetSize_SeekToEnd(op.stream, fileSize));
+    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
     RINOK(op.callback->SetTotal(NULL, &fileSize))
   }
   */
@@ -3119,7 +3002,7 @@ HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
   HRESULT res = OpenStream(op);
   IgnoreSplit = false;
   
-  #ifdef Z7_SFX
+  #ifdef _SFX
   
   if (res != S_FALSE
       || !fileStreamSpec
@@ -3135,10 +3018,10 @@ HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
       FOR_VECTOR (i, op.codecs->Formats)
       {
         const CArcInfoEx &ai = op.codecs->Formats[i];
-        if (ai.Is_Split())
+        if (ai.IsSplit())
           continue;
         UString path3 = path2;
-        path3.Add_Dot();
+        path3 += '.';
         path3 += ai.GetMainExt(); // "7z"  for SFX.
         Path = path3;
         Path += ".001";
@@ -3184,7 +3067,7 @@ HRESULT CArchiveLink::Close()
   for (unsigned i = Arcs.Size(); i != 0;)
   {
     i--;
-    RINOK(Arcs[i].Close())
+    RINOK(Arcs[i].Close());
   }
   IsOpen = false;
   // ErrorsText.Empty();
@@ -3317,13 +3200,13 @@ HRESULT CArchiveLink::Open(COpenOptions &op)
     UInt32 mainSubfile;
     {
       NCOM::CPropVariant prop;
-      RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop))
+      RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop));
       if (prop.vt == VT_UI4)
         mainSubfile = prop.ulVal;
       else
         break;
       UInt32 numItems;
-      RINOK(arc.Archive->GetNumberOfItems(&numItems))
+      RINOK(arc.Archive->GetNumberOfItems(&numItems));
       if (mainSubfile >= numItems)
         break;
     }
@@ -3342,17 +3225,16 @@ HRESULT CArchiveLink::Open(COpenOptions &op)
       break;
     
     CArc arc2;
-    RINOK(arc.GetItem_Path(mainSubfile, arc2.Path))
+    RINOK(arc.GetItemPath(mainSubfile, arc2.Path));
 
     bool zerosTailIsAllowed;
-    RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed))
+    RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed));
 
 
     if (op.callback)
     {
-      Z7_DECL_CMyComPtr_QI_FROM(
-          IArchiveOpenSetSubArchiveName,
-          setSubArchiveName, op.callback)
+      CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
+      op.callback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
       if (setSubArchiveName)
         setSubArchiveName->SetSubArchiveName(arc2.Path);
     }
@@ -3363,7 +3245,7 @@ HRESULT CArchiveLink::Open(COpenOptions &op)
     CIntVector excl;
 
     COpenOptions op2;
-    #ifndef Z7_SFX
+    #ifndef _SFX
     op2.props = op.props;
     #endif
     op2.codecs = op.codecs;
@@ -3386,8 +3268,8 @@ HRESULT CArchiveLink::Open(COpenOptions &op)
       NonOpen_ArcPath = arc2.Path;
       break;
     }
-    RINOK(result)
-    RINOK(arc.GetItem_MTime(mainSubfile, arc2.MTime))
+    RINOK(result);
+    RINOK(arc.GetItemMTime(mainSubfile, arc2.MTime, arc2.MTimeDefined));
     Arcs.Add(arc2);
   }
   IsOpen = !Arcs.IsEmpty();
@@ -3406,7 +3288,7 @@ HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
   if (!op.stream && !op.stdInMode)
   {
     NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), prefix, name);
-    RINOK(openCallbackSpec->Init2(prefix, name))
+    openCallbackSpec->Init(prefix, name);
   }
   else
   {
@@ -3421,7 +3303,7 @@ HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
   PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
   // Password = openCallbackSpec->Password;
 
-  RINOK(res)
+  RINOK(res);
   // VolumePaths.Add(fs2us(prefix + name));
 
   FOR_VECTOR (i, openCallbackSpec->FileNames_WasUsed)
@@ -3436,7 +3318,7 @@ HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
   return S_OK;
 }
 
-HRESULT CArc::ReOpen(const COpenOptions &op, IArchiveOpenCallback *openCallback_Additional)
+HRESULT CArc::ReOpen(const COpenOptions &op)
 {
   ErrorInfo.ClearErrors();
   ErrorInfo.ErrorFormatIndex = -1;
@@ -3444,9 +3326,8 @@ HRESULT CArc::ReOpen(const COpenOptions &op, IArchiveOpenCallback *openCallback_
   UInt64 fileSize = 0;
   if (op.stream)
   {
-    RINOK(InStream_SeekToBegin(op.stream))
-    RINOK(InStream_AtBegin_GetSize(op.stream, fileSize))
-    // RINOK(InStream_GetSize_SeekToBegin(op.stream, fileSize))
+    RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
+    RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
   }
   FileSize = fileSize;
 
@@ -3459,23 +3340,20 @@ HRESULT CArc::ReOpen(const COpenOptions &op, IArchiveOpenCallback *openCallback_
     CTailInStream *tailStreamSpec = new CTailInStream;
     stream2 = tailStreamSpec;
     tailStreamSpec->Stream = op.stream;
-    tailStreamSpec->Offset = (UInt64)globalOffset;
+    tailStreamSpec->Offset = globalOffset;
     tailStreamSpec->Init();
-    RINOK(tailStreamSpec->SeekToStart())
+    RINOK(tailStreamSpec->SeekToStart());
   }
 
   // There are archives with embedded STUBs (like ZIP), so we must support signature scanning
   // But for another archives we can use 0 here. So the code can be fixed !!!
   UInt64 maxStartPosition = kMaxCheckStartPosition;
-  IArchiveOpenCallback *openCallback = openCallback_Additional;
-  if (!openCallback)
-    openCallback = op.callback;
-  HRESULT res = Archive->Open(stream2, &maxStartPosition, openCallback);
+  HRESULT res = Archive->Open(stream2, &maxStartPosition, op.callback);
   
   if (res == S_OK)
   {
-    RINOK(ReadBasicProps(Archive, (UInt64)globalOffset, res))
-    ArcStreamOffset = (UInt64)globalOffset;
+    RINOK(ReadBasicProps(Archive, globalOffset, res));
+    ArcStreamOffset = globalOffset;
     if (ArcStreamOffset != 0)
       InStream = op.stream;
   }
@@ -3487,7 +3365,7 @@ HRESULT CArchiveLink::Open3(COpenOptions &op, IOpenCallbackUI *callbackUI)
   HRESULT res = Open2(op, callbackUI);
   if (callbackUI)
   {
-    RINOK(callbackUI->Open_Finished())
+    RINOK(callbackUI->Open_Finished());
   }
   return res;
 }
@@ -3507,8 +3385,6 @@ HRESULT CArchiveLink::ReOpen(COpenOptions &op)
   if (Arcs.Size() == 0) // ???
     return Open2(op, NULL);
 
-  /* if archive is multivolume (unsupported here still)
-     COpenCallbackImp object will exist after Open stage. */
   COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
   CMyComPtr<IArchiveOpenCallback> openCallbackNew = openCallbackSpec;
 
@@ -3517,20 +3393,18 @@ HRESULT CArchiveLink::ReOpen(COpenOptions &op)
   {
     FString dirPrefix, fileName;
     NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), dirPrefix, fileName);
-    RINOK(openCallbackSpec->Init2(dirPrefix, fileName))
+    openCallbackSpec->Init(dirPrefix, fileName);
   }
 
 
   CInFileStream *fileStreamSpec = new CInFileStream;
   CMyComPtr<IInStream> stream(fileStreamSpec);
   if (!fileStreamSpec->Open(us2fs(op.filePath)))
-    return GetLastError_noZero_HRESULT();
+    return GetLastError();
   op.stream = stream;
 
   CArc &arc = Arcs[0];
-  const HRESULT res = arc.ReOpen(op, openCallbackNew);
-
-  openCallbackSpec->ReOpenCallback = NULL;
+  HRESULT res = arc.ReOpen(op);
   
   PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
   // Password = openCallbackSpec->Password;
@@ -3539,9 +3413,8 @@ HRESULT CArchiveLink::ReOpen(COpenOptions &op)
   return res;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
-bool ParseComplexSize(const wchar_t *s, UInt64 &result);
 bool ParseComplexSize(const wchar_t *s, UInt64 &result)
 {
   result = 0;
@@ -3583,7 +3456,6 @@ static bool ParseTypeParams(const UString &s, COpenType &type)
       case 'e': type.EachPos = true; return true;
       case 'a': type.CanReturnArc = true; return true;
       case 'r': type.Recursive = true; return true;
-      default: break;
     }
     return false;
   }
@@ -3600,7 +3472,7 @@ static bool ParseTypeParams(const UString &s, COpenType &type)
   return false;
 }
 
-static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
+bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
 {
   int pos2 = s.Find(L':');
 
@@ -3609,11 +3481,11 @@ static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
   if (pos2 < 0)
   {
     name = s;
-    pos2 = (int)s.Len();
+    pos2 = s.Len();
   }
   else
   {
-    name = s.Left((unsigned)pos2);
+    name = s.Left(pos2);
     pos2++;
   }
 
@@ -3634,12 +3506,6 @@ static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
       type.CanReturnArc = false;
       type.CanReturnParser = true;
     }
-    else if (name.IsEqualTo_Ascii_NoCase("hash"))
-    {
-      // type.CanReturnArc = false;
-      // type.CanReturnParser = false;
-      type.IsHashType = true;
-    }
     else
       return false;
   }
@@ -3648,17 +3514,17 @@ static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
 
   }
  
-  for (unsigned i = (unsigned)pos2; i < s.Len();)
+  for (unsigned i = pos2; i < s.Len();)
   {
     int next = s.Find(L':', i);
     if (next < 0)
-      next = (int)s.Len();
-    const UString name = s.Mid(i, (unsigned)next - i);
+      next = s.Len();
+    const UString name = s.Mid(i, next - i);
     if (name.IsEmpty())
       return false;
     if (!ParseTypeParams(name, type))
       return false;
-    i = (unsigned)next + 1;
+    i = next + 1;
   }
   
   return true;
@@ -3667,36 +3533,21 @@ static bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
 bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types)
 {
   types.Clear();
-  bool isHashType = false;
   for (unsigned pos = 0; pos < s.Len();)
   {
     int pos2 = s.Find(L'.', pos);
     if (pos2 < 0)
-      pos2 = (int)s.Len();
-    UString name = s.Mid(pos, (unsigned)pos2 - pos);
+      pos2 = s.Len();
+    UString name = s.Mid(pos, pos2 - pos);
     if (name.IsEmpty())
       return false;
     COpenType type;
     if (!ParseType(codecs, name, type))
       return false;
-    if (isHashType)
-      return false;
-    if (type.IsHashType)
-      isHashType = true;
     types.Add(type);
-    pos = (unsigned)pos2 + 1;
+    pos = pos2 + 1;
   }
   return true;
 }
 
-/*
-bool IsHashType(const CObjectVector<COpenType> &types)
-{
-  if (types.Size() != 1)
-    return false;
-  return types[0].IsHashType;
-}
-*/
-
-
 #endif