react-native-update 10.34.3 → 10.34.4

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

@@ -1,7 +1,7 @@
 // LoadCodecs.cpp
 
 /*
-Z7_EXTERNAL_CODECS
+EXTERNAL_CODECS
 ---------------
   CCodecs::Load() tries to detect the directory with plugins.
   It stops the checking, if it can find any of the following items:
@@ -22,7 +22,7 @@ Z7_EXTERNAL_CODECS
 
 EXPORT_CODECS
 -------------
-  if (Z7_EXTERNAL_CODECS) is defined, then the code exports internal
+  if (EXTERNAL_CODECS) is defined, then the code exports internal
   codecs of client from CCodecs object to external plugins.
   7-Zip doesn't use that feature. 7-Zip uses the scheme:
     - client application without internal plugins.
@@ -33,25 +33,38 @@ EXPORT_CODECS
 
 #include "StdAfx.h"
 
+#include "../../../../C/7zVersion.h"
+
 #include "../../../Common/MyCom.h"
 #include "../../../Common/StringToInt.h"
 #include "../../../Common/StringConvert.h"
 
-#include "../../../Windows/ErrorMsg.h"
-#include "../../../Windows/FileIO.h"
 #include "../../../Windows/PropVariant.h"
 
 #include "LoadCodecs.h"
 
+using namespace NWindows;
+
+#ifdef NEW_FOLDER_INTERFACE
+#include "../../../Common/StringToInt.h"
+#endif
+
 #include "../../ICoder.h"
 #include "../../Common/RegisterArc.h"
-#include "../../Common/RegisterCodec.h"
 
-#ifdef Z7_EXTERNAL_CODECS
+#ifdef EXTERNAL_CODECS
+
 // #define EXPORT_CODECS
+
+#endif
+
+#ifdef NEW_FOLDER_INTERFACE
+extern HINSTANCE g_hInstance;
+#include "../../../Windows/ResourceString.h"
+static const UINT kIconTypesResId = 100;
 #endif
 
-#ifdef Z7_EXTERNAL_CODECS
+#ifdef EXTERNAL_CODECS
 
 #include "../../../Windows/FileFind.h"
 #include "../../../Windows/DLL.h"
@@ -61,7 +74,6 @@ EXPORT_CODECS
 #include "../../../Windows/Registry.h"
 #endif
 
-using namespace NWindows;
 using namespace NFile;
 
 
@@ -70,11 +82,11 @@ using namespace NFile;
 
 
 static CFSTR const kMainDll =
-  #ifdef _WIN32
+  // #ifdef _WIN32
     FTEXT("7z.dll");
-  #else
-    FTEXT("7z.so");
-  #endif
+  // #else
+  // FTEXT("7z.so");
+  // #endif
 
 
 #ifdef _WIN32
@@ -98,7 +110,7 @@ static bool ReadPathFromRegistry(HKEY baseKey, LPCWSTR value, FString &path)
     {
       path = us2fs(pathU);
       NName::NormalizeDirPathPrefix(path);
-      return NFind::DoesFileExist_Raw(path + kMainDll);
+      return NFind::DoesFileExist(path + kMainDll);
     }
   }
   return false;
@@ -106,10 +118,10 @@ static bool ReadPathFromRegistry(HKEY baseKey, LPCWSTR value, FString &path)
 
 #endif // _WIN32
 
-#endif // Z7_EXTERNAL_CODECS
+#endif // EXTERNAL_CODECS
 
 
-static const unsigned kNumArcsMax = 72;
+static const unsigned kNumArcsMax = 64;
 static unsigned g_NumArcs = 0;
 static const CArcInfo *g_Arcs[kNumArcsMax];
 
@@ -120,10 +132,8 @@ void RegisterArc(const CArcInfo *arcInfo) throw()
     g_Arcs[g_NumArcs] = arcInfo;
     g_NumArcs++;
   }
-  // else throw 1;
 }
 
-/*
 static void SplitString(const UString &srcString, UStringVector &destStrings)
 {
   destStrings.Clear();
@@ -148,13 +158,12 @@ static void SplitString(const UString &srcString, UStringVector &destStrings)
   if (!s.IsEmpty())
     destStrings.Add(s);
 }
-*/
 
 int CArcInfoEx::FindExtension(const UString &ext) const
 {
   FOR_VECTOR (i, Exts)
     if (ext.IsEqualTo_NoCase(Exts[i].Ext))
-      return (int)i;
+      return i;
   return -1;
 }
 
@@ -170,21 +179,21 @@ void CArcInfoEx::AddExts(const UString &ext, const UString &addExt)
     if (i < addExts.Size())
     {
       extInfo.AddExt = addExts[i];
-      if (extInfo.AddExt.IsEqualTo("*"))
+      if (extInfo.AddExt == L"*")
         extInfo.AddExt.Empty();
     }
     Exts.Add(extInfo);
   }
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 static bool ParseSignatures(const Byte *data, unsigned size, CObjectVector<CByteBuffer> &signatures)
 {
   signatures.Clear();
-  while (size != 0)
+  while (size > 0)
   {
-    const unsigned len = *data++;
+    unsigned len = *data++;
     size--;
     if (len > size)
       return false;
@@ -195,20 +204,17 @@ static bool ParseSignatures(const Byte *data, unsigned size, CObjectVector<CByte
   return true;
 }
 
-#endif // Z7_SFX
-
-// #include <stdio.h>
+#endif // _SFX
 
-#ifdef Z7_EXTERNAL_CODECS
+#ifdef EXTERNAL_CODECS
 
 static FString GetBaseFolderPrefixFromRegistry()
 {
   FString moduleFolderPrefix = NDLL::GetModuleDirPrefix();
-  
   #ifdef _WIN32
-  if (   !NFind::DoesFileOrDirExist(moduleFolderPrefix + kMainDll)
-      && !NFind::DoesFileOrDirExist(moduleFolderPrefix + kCodecsFolderName)
-      && !NFind::DoesFileOrDirExist(moduleFolderPrefix + kFormatsFolderName))
+  if (!NFind::DoesFileExist(moduleFolderPrefix + kMainDll) &&
+      !NFind::DoesDirExist(moduleFolderPrefix + kCodecsFolderName) &&
+      !NFind::DoesDirExist(moduleFolderPrefix + kFormatsFolderName))
   {
     FString path;
     if (ReadPathFromRegistry(HKEY_CURRENT_USER,  kProgramPath2Value, path)) return path;
@@ -217,8 +223,6 @@ static FString GetBaseFolderPrefixFromRegistry()
     if (ReadPathFromRegistry(HKEY_LOCAL_MACHINE, kProgramPathValue,  path)) return path;
   }
   #endif
-  
-  // printf("\nmoduleFolderPrefix = %s\n", (const char *)GetAnsiString(moduleFolderPrefix));
   return moduleFolderPrefix;
 }
 
@@ -228,84 +232,50 @@ static HRESULT GetCoderClass(Func_GetMethodProperty getMethodProperty, UInt32 in
 {
   NCOM::CPropVariant prop;
   isAssigned = false;
-  RINOK(getMethodProperty(index, propId, &prop))
+  RINOK(getMethodProperty(index, propId, &prop));
   if (prop.vt == VT_BSTR)
   {
     if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
       return E_FAIL;
     isAssigned = true;
-    clsId = *(const GUID *)(const void *)prop.bstrVal;
+    clsId = *(const GUID *)prop.bstrVal;
   }
   else if (prop.vt != VT_EMPTY)
     return E_FAIL;
   return S_OK;
 }
 
-
-static HRESULT GetMethodBoolProp(Func_GetMethodProperty getMethodProperty, UInt32 index,
-    PROPID propId, bool &resVal, bool &isAssigned)
-{
-  NCOM::CPropVariant prop;
-  resVal = false;
-  isAssigned = false;
-  RINOK(getMethodProperty(index, propId, &prop))
-  if (prop.vt == VT_BOOL)
-  {
-    isAssigned = true;
-    resVal = VARIANT_BOOLToBool(prop.boolVal);
-  }
-  else if (prop.vt != VT_EMPTY)
-    return E_FAIL;
-  return S_OK;
-}
-
-#if defined(__clang__)
-#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
-#endif
-
-#ifdef _WIN32
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
-#endif
-
-#define MY_GET_FUNC(dest, type, lib, func)  \
-  dest = Z7_GET_PROC_ADDRESS(type, lib.Get_HMODULE(), func);
-// #define MY_GET_FUNC(dest, type, func)  dest = (type)(func);
-
-#define MY_GET_FUNC_LOC(dest, type, lib, func) \
-  type dest;  MY_GET_FUNC(dest, type, lib, func)
-
 HRESULT CCodecs::LoadCodecs()
 {
   CCodecLib &lib = Libs.Back();
 
-  MY_GET_FUNC (lib.CreateDecoder,     Func_CreateDecoder,     lib.Lib, "CreateDecoder")
-  MY_GET_FUNC (lib.CreateEncoder,     Func_CreateEncoder,     lib.Lib, "CreateEncoder")
-  MY_GET_FUNC (lib.GetMethodProperty, Func_GetMethodProperty, lib.Lib, "GetMethodProperty")
+  lib.CreateDecoder = (Func_CreateDecoder)lib.Lib.GetProc("CreateDecoder");
+  lib.CreateEncoder = (Func_CreateEncoder)lib.Lib.GetProc("CreateEncoder");
+  lib.GetMethodProperty = (Func_GetMethodProperty)lib.Lib.GetProc("GetMethodProperty");
 
   if (lib.GetMethodProperty)
   {
     UInt32 numMethods = 1;
-    MY_GET_FUNC_LOC (getNumberOfMethods, Func_GetNumberOfMethods, lib.Lib, "GetNumberOfMethods")
+    Func_GetNumberOfMethods getNumberOfMethods = (Func_GetNumberOfMethods)lib.Lib.GetProc("GetNumberOfMethods");
     if (getNumberOfMethods)
     {
-      RINOK(getNumberOfMethods(&numMethods))
+      RINOK(getNumberOfMethods(&numMethods));
     }
     for (UInt32 i = 0; i < numMethods; i++)
     {
       CDllCodecInfo info;
       info.LibIndex = Libs.Size() - 1;
       info.CodecIndex = i;
-      RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kEncoder, info.Encoder, info.EncoderIsAssigned))
-      RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kDecoder, info.Decoder, info.DecoderIsAssigned))
-      RINOK(GetMethodBoolProp(lib.GetMethodProperty, i, NMethodPropID::kIsFilter, info.IsFilter, info.IsFilter_Assigned))
+      RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kEncoder, info.Encoder, info.EncoderIsAssigned));
+      RINOK(GetCoderClass(lib.GetMethodProperty, i, NMethodPropID::kDecoder, info.Decoder, info.DecoderIsAssigned));
       Codecs.Add(info);
     }
   }
 
-  MY_GET_FUNC_LOC (getHashers, Func_GetHashers, lib.Lib, "GetHashers")
+  Func_GetHashers getHashers = (Func_GetHashers)lib.Lib.GetProc("GetHashers");
   if (getHashers)
   {
-    RINOK(getHashers(&lib.ComHashers))
+    RINOK(getHashers(&lib.ComHashers));
     if (lib.ComHashers)
     {
       UInt32 numMethods = lib.ComHashers->GetNumHashers();
@@ -328,7 +298,7 @@ static HRESULT GetProp(
     UInt32 index, PROPID propID, NCOM::CPropVariant &prop)
 {
   if (getProp2)
-    return getProp2(index, propID, &prop);
+    return getProp2(index, propID, &prop);;
   return getProp(propID, &prop);
 }
 
@@ -339,7 +309,7 @@ static HRESULT GetProp_Bool(
 {
   res = false;
   NCOM::CPropVariant prop;
-  RINOK(GetProp(getProp, getProp2, index, propID, prop))
+  RINOK(GetProp(getProp, getProp2, index, propID, prop));
   if (prop.vt == VT_BOOL)
     res = VARIANT_BOOLToBool(prop.boolVal);
   else if (prop.vt != VT_EMPTY)
@@ -355,7 +325,7 @@ static HRESULT GetProp_UInt32(
   res = 0;
   defined = false;
   NCOM::CPropVariant prop;
-  RINOK(GetProp(getProp, getProp2, index, propID, prop))
+  RINOK(GetProp(getProp, getProp2, index, propID, prop));
   if (prop.vt == VT_UI4)
   {
     res = prop.ulVal;
@@ -373,7 +343,7 @@ static HRESULT GetProp_String(
 {
   res.Empty();
   NCOM::CPropVariant prop;
-  RINOK(GetProp(getProp, getProp2, index, propID, prop))
+  RINOK(GetProp(getProp, getProp2, index, propID, prop));
   if (prop.vt == VT_BSTR)
     res.SetFromBstr(prop.bstrVal);
   else if (prop.vt != VT_EMPTY)
@@ -388,7 +358,7 @@ static HRESULT GetProp_RawData(
 {
   bb.Free();
   NCOM::CPropVariant prop;
-  RINOK(GetProp(getProp, getProp2, index, propID, prop))
+  RINOK(GetProp(getProp, getProp2, index, propID, prop));
   if (prop.vt == VT_BSTR)
   {
     UINT len = ::SysStringByteLen(prop.bstrVal);
@@ -411,22 +381,22 @@ HRESULT CCodecs::LoadFormats()
   const NDLL::CLibrary &lib = Libs.Back().Lib;
   
   Func_GetHandlerProperty getProp = NULL;
-  MY_GET_FUNC_LOC (getProp2, Func_GetHandlerProperty2, lib, "GetHandlerProperty2")
-  MY_GET_FUNC_LOC (getIsArc, Func_GetIsArc, lib, "GetIsArc")
+  Func_GetHandlerProperty2 getProp2 = (Func_GetHandlerProperty2)lib.GetProc("GetHandlerProperty2");
+  Func_GetIsArc getIsArc = (Func_GetIsArc)lib.GetProc("GetIsArc");
   
   UInt32 numFormats = 1;
 
   if (getProp2)
   {
-    MY_GET_FUNC_LOC (getNumberOfFormats, Func_GetNumberOfFormats, lib, "GetNumberOfFormats")
+    Func_GetNumberOfFormats getNumberOfFormats = (Func_GetNumberOfFormats)lib.GetProc("GetNumberOfFormats");
     if (getNumberOfFormats)
     {
-      RINOK(getNumberOfFormats(&numFormats))
+      RINOK(getNumberOfFormats(&numFormats));
     }
   }
   else
   {
-    MY_GET_FUNC (getProp, Func_GetHandlerProperty, lib, "GetHandlerProperty")
+    getProp = (Func_GetHandlerProperty)lib.GetProc("GetHandlerProperty");
     if (!getProp)
       return S_OK;
   }
@@ -434,10 +404,10 @@ HRESULT CCodecs::LoadFormats()
   for (UInt32 i = 0; i < numFormats; i++)
   {
     CArcInfoEx item;
-    item.LibIndex = (int)(Libs.Size() - 1);
+    item.LibIndex = Libs.Size() - 1;
     item.FormatIndex = i;
 
-    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kName, item.Name))
+    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kName, item.Name));
 
     {
       NCOM::CPropVariant prop;
@@ -447,23 +417,23 @@ HRESULT CCodecs::LoadFormats()
         continue;
       if (::SysStringByteLen(prop.bstrVal) != sizeof(GUID))
         return E_FAIL;
-      item.ClassID = *(const GUID *)(const void *)prop.bstrVal;
+      item.ClassID = *(const GUID *)prop.bstrVal;
       prop.Clear();
     }
 
     UString ext, addExt;
-    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kExtension, ext))
-    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kAddExtension, addExt))
+    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kExtension, ext));
+    RINOK(GetProp_String(getProp, getProp2, i, NArchive::NHandlerPropID::kAddExtension, addExt));
     item.AddExts(ext, addExt);
 
     GetProp_Bool(getProp, getProp2, i, NArchive::NHandlerPropID::kUpdate, item.UpdateEnabled);
     bool flags_Defined = false;
-    RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kFlags, item.Flags, flags_Defined))
+    RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kFlags, item.Flags, flags_Defined));
     item.NewInterface = flags_Defined;
     if (!flags_Defined) // && item.UpdateEnabled
     {
       // support for DLL version before 9.31:
-      for (unsigned j = 0; j < Z7_ARRAY_SIZE(kArcFlagsPars); j += 2)
+      for (unsigned j = 0; j < ARRAY_SIZE(kArcFlagsPars); j += 2)
       {
         bool val = false;
         GetProp_Bool(getProp, getProp2, i, kArcFlagsPars[j], val);
@@ -471,24 +441,19 @@ HRESULT CCodecs::LoadFormats()
           item.Flags |= kArcFlagsPars[j + 1];
       }
     }
-
-    {
-      bool defined = false;
-      RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kTimeFlags, item.TimeFlags, defined))
-    }
     
     CByteBuffer sig;
-    RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kSignature, sig))
+    RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kSignature, sig));
     if (sig.Size() != 0)
       item.Signatures.Add(sig);
     else
     {
-      RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kMultiSignature, sig))
+      RINOK(GetProp_RawData(getProp, getProp2, i, NArchive::NHandlerPropID::kMultiSignature, sig));
       ParseSignatures(sig, (unsigned)sig.Size(), item.Signatures);
     }
 
     bool signatureOffset_Defined;
-    RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kSignatureOffset, item.SignatureOffset, signatureOffset_Defined))
+    RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kSignatureOffset, item.SignatureOffset, signatureOffset_Defined));
     
     // bool version_Defined;
     // RINOK(GetProp_UInt32(getProp, getProp2, i, NArchive::NHandlerPropID::kVersion, item.Version, version_Defined));
@@ -501,174 +466,60 @@ HRESULT CCodecs::LoadFormats()
   return S_OK;
 }
 
-#ifdef Z7_LARGE_PAGES
+#ifdef _7ZIP_LARGE_PAGES
 extern "C"
 {
   extern SIZE_T g_LargePageSize;
 }
 #endif
 
-
-void CCodecs::AddLastError(const FString &path)
-{
-  const HRESULT res = GetLastError_noZero_HRESULT();
-  CCodecError &error = Errors.AddNew();
-  error.Path = path;
-  error.ErrorCode = res;
-}
-
-
-static bool IsSupportedDll(CCodecLib &lib)
-{
-  MY_GET_FUNC_LOC (
-     f_GetModuleProp,
-  Func_GetModuleProp, lib.Lib,
-      "GetModuleProp")
-  /* p7zip and 7-Zip before v23 used virtual destructor in IUnknown,
-     if _WIN32 is not defined */
-  UInt32 flags =
-    #ifdef _WIN32
-      NModuleInterfaceType::k_IUnknown_VirtDestructor_No;
-    #else
-      NModuleInterfaceType::k_IUnknown_VirtDestructor_Yes;
-    #endif
-  if (f_GetModuleProp)
-  {
-    {
-      NCOM::CPropVariant prop;
-      if (f_GetModuleProp(NModulePropID::kInterfaceType, &prop) == S_OK)
-      {
-        if (prop.vt == VT_UI4)
-          flags = prop.ulVal;
-        else if (prop.vt != VT_EMPTY)
-          return false;
-      }
-    }
-    {
-      NCOM::CPropVariant prop;
-      if (f_GetModuleProp(NModulePropID::kVersion, &prop) == S_OK)
-      {
-        if (prop.vt == VT_UI4)
-          lib.Version = prop.ulVal;
-      }
-    }
-  }
-  if (
-      flags
-      // (flags & NModuleFlags::kMask)
-      != NModuleInterfaceType::k_IUnknown_VirtDestructor_ThisModule)
-    return false;
-  return true;
-}
-    
-
 HRESULT CCodecs::LoadDll(const FString &dllPath, bool needCheckDll, bool *loadedOK)
 {
   if (loadedOK)
     *loadedOK = false;
 
-  // needCheckDll = 1;
-
-  #ifdef _WIN32
   if (needCheckDll)
   {
     NDLL::CLibrary lib;
     if (!lib.LoadEx(dllPath, LOAD_LIBRARY_AS_DATAFILE))
-    {
-      /* if is not win32
-      //  %1 is not a valid Win32 application.
-      //  #define ERROR_BAD_EXE_FORMAT             193L
-      */
-      // return GetLastError_noZero_HRESULT();
-      const DWORD lastError = GetLastError();
-      if (lastError != ERROR_BAD_EXE_FORMAT)
-      {
-        CCodecError &error = Errors.AddNew();
-        error.Path = dllPath;
-        error.Message = "cannot load file as datafile library";
-        error.ErrorCode = HRESULT_FROM_WIN32(lastError);
-      }
       return S_OK;
-    }
   }
-  #else
-  UNUSED_VAR(needCheckDll)
-  #endif
   
   Libs.AddNew();
   CCodecLib &lib = Libs.Back();
   lib.Path = dllPath;
   bool used = false;
-  // HRESULT res = S_OK;
+  HRESULT res = S_OK;
   
- if (lib.Lib.Load(dllPath))
- {
-  if (!IsSupportedDll(lib))
-  {
-    CCodecError &error = Errors.AddNew();
-    error.Path = dllPath;
-    error.Message = "the module is not compatible with program";
-  }
-  else
+  if (lib.Lib.Load(dllPath))
   {
     if (loadedOK)
       *loadedOK = true;
-    /*
     #ifdef NEW_FOLDER_INTERFACE
     lib.LoadIcons();
     #endif
-    */
 
-    /*
-    {
-      MY_GET_FUNC_LOC (_libStartup, Func_libStartup, lib.Lib, "LibStartup")
-      if (_libStartup)
-      {
-        HRESULT res = _libStartup();
-        if (res != 0)
-        {
-          CCodecError &error = Errors.AddNew();
-          error.Path = dllPath;
-          error.ErrorCode = res;
-        }
-      }
-    }
-    */
-
-    #ifdef Z7_LARGE_PAGES
+    #ifdef _7ZIP_LARGE_PAGES
     if (g_LargePageSize != 0)
     {
-      MY_GET_FUNC_LOC (setLargePageMode, Func_SetLargePageMode, lib.Lib, "SetLargePageMode")
+      Func_SetLargePageMode setLargePageMode = (Func_SetLargePageMode)lib.Lib.GetProc("SetLargePageMode");
       if (setLargePageMode)
         setLargePageMode();
     }
     #endif
 
-    if (CaseSensitive_Change)
+    if (CaseSensitiveChange)
     {
-      MY_GET_FUNC_LOC (setCaseSensitive, Func_SetCaseSensitive, lib.Lib, "SetCaseSensitive")
+      Func_SetCaseSensitive setCaseSensitive = (Func_SetCaseSensitive)lib.Lib.GetProc("SetCaseSensitive");
       if (setCaseSensitive)
         setCaseSensitive(CaseSensitive ? 1 : 0);
     }
 
-    /*
-    {
-      MY_GET_FUNC_LOC (setClientVersion, Func_SetClientVersion, lib.Lib, "SetClientVersion")
-      if (setClientVersion)
-      {
-        // const UInt32 kVersion = (MY_VER_MAJOR << 16) | MY_VER_MINOR;
-        setClientVersion(g_ClientVersion);
-      }
-    }
-    */
-
-
-    MY_GET_FUNC (lib.CreateObject, Func_CreateObject, lib.Lib, "CreateObject")
+    lib.CreateObject = (Func_CreateObject)lib.Lib.GetProc("CreateObject");
     {
       unsigned startSize = Codecs.Size() + Hashers.Size();
-      HRESULT res = LoadCodecs();
-      if (startSize != Codecs.Size() + Hashers.Size())
-        used = true;
+      res = LoadCodecs();
+      used = (startSize != Codecs.Size() + Hashers.Size());
       if (res == S_OK && lib.CreateObject)
       {
         startSize = Formats.Size();
@@ -676,71 +527,25 @@ HRESULT CCodecs::LoadDll(const FString &dllPath, bool needCheckDll, bool *loaded
         if (startSize != Formats.Size())
           used = true;
       }
-      if (res != S_OK)
-      {
-        CCodecError &error = Errors.AddNew();
-        error.Path = dllPath;
-        error.ErrorCode = res;
-      }
-    }
-    // plugins can use non-7-zip dlls, so we silently ignore non7zip DLLs
-    /*
-    if (!used)
-    {
-      CCodecError &error = Errors.AddNew();
-      error.Path = dllPath;
-      error.Message = "no 7-Zip code";
     }
-    */
-  }
- }
- else
-  {
-    AddLastError(dllPath);
   }
   
   if (!used)
     Libs.DeleteBack();
 
-  return S_OK;
+  return res;
 }
 
-HRESULT CCodecs::LoadDllsFromFolder(const FString &folderPath)
+HRESULT CCodecs::LoadDllsFromFolder(const FString &folderPrefix)
 {
-  if (!NFile::NFind::DoesDirExist_FollowLink(folderPath))
-  // if (!NFile::NFind::DoesDirExist(folderPath))
-  {
-    // AddLastError(folderPath);
-    return S_OK;
-  }
-
-  FString folderPrefix = folderPath;
-  folderPrefix.Add_PathSepar();
-
   NFile::NFind::CEnumerator enumerator;
   enumerator.SetDirPrefix(folderPrefix);
-  NFile::NFind::CDirEntry fi;
-  for (;;)
+  NFile::NFind::CFileInfo fi;
+  while (enumerator.Next(fi))
   {
-    bool found;
-    if (!enumerator.Next(fi, found))
-    {
-      // it can be wrong Symbolic link to folder here
-      AddLastError(folderPath);
-      break;
-      // return GetLastError_noZero_HRESULT();
-    }
-    if (!found)
-      break;
-    #ifdef _WIN32
     if (fi.IsDir())
       continue;
-    #else
-    if (enumerator.DirEntry_IsDir(fi, true)) // followLink
-      continue;
-    #endif
-
-    RINOK(LoadDll(folderPrefix + fi.Name, true))
+    RINOK(LoadDll(folderPrefix + fi.Name, true));
   }
   return S_OK;
 }
@@ -768,21 +573,18 @@ void CCodecs::CloseLibs()
   // OutputDebugStringA("~CloseLibs end");
 }
 
-#endif // Z7_EXTERNAL_CODECS
+#endif // EXTERNAL_CODECS
 
 
 HRESULT CCodecs::Load()
 {
-  /*
   #ifdef NEW_FOLDER_INTERFACE
   InternalIcons.LoadIcons(g_hInstance);
   #endif
-  */
 
   Formats.Clear();
   
-  #ifdef Z7_EXTERNAL_CODECS
-    Errors.Clear();
+  #ifdef EXTERNAL_CODECS
     MainDll_ErrorPath.Empty();
     Codecs.Clear();
     Hashers.Clear();
@@ -807,7 +609,7 @@ HRESULT CCodecs::Load()
       item.AddExts(e, ae);
     }
 
-    #ifndef Z7_SFX
+    #ifndef _SFX
 
     item.CreateOutArchive = arc.CreateOutArchive;
     item.UpdateEnabled = (arc.CreateOutArchive != NULL);
@@ -818,28 +620,23 @@ HRESULT CCodecs::Load()
     if (arc.IsMultiSignature())
       ParseSignatures(arc.Signature, arc.SignatureSize, item.Signatures);
     else
-    {
-      if (arc.SignatureSize != 0) // 21.04
-        item.Signatures.AddNew().CopyFrom(arc.Signature, arc.SignatureSize);
-    }
+      item.Signatures.AddNew().CopyFrom(arc.Signature, arc.SignatureSize);
     
     #endif
 
     Formats.Add(item);
   }
   
-  // printf("\nLoad codecs \n");
-
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
     const FString baseFolder = GetBaseFolderPrefixFromRegistry();
     {
       bool loadedOK;
-      RINOK(LoadDll(baseFolder + kMainDll, false, &loadedOK))
+      RINOK(LoadDll(baseFolder + kMainDll, false, &loadedOK));
       if (!loadedOK)
         MainDll_ErrorPath = kMainDll;
     }
-    RINOK(LoadDllsFromFolder(baseFolder + kCodecsFolderName))
-    RINOK(LoadDllsFromFolder(baseFolder + kFormatsFolderName))
+    RINOK(LoadDllsFromFolder(baseFolder + kCodecsFolderName FSTRING_PATH_SEPARATOR));
+    RINOK(LoadDllsFromFolder(baseFolder + kFormatsFolderName FSTRING_PATH_SEPARATOR));
 
   NeedSetLibCodecs = true;
     
@@ -862,29 +659,27 @@ HRESULT CCodecs::Load()
     FOR_VECTOR(i, Libs)
     {
       CCodecLib &lib = Libs[i];
-      MY_GET_FUNC (lib.SetCodecs, Func_SetCodecs, lib.Lib, "SetCodecs")
+      lib.SetCodecs = (Func_SetCodecs)lib.Lib.GetProc("SetCodecs");
       if (lib.SetCodecs)
       {
-        RINOK(lib.SetCodecs(this))
+        RINOK(lib.SetCodecs(this));
       }
     }
   }
 
   #endif
 
-  // we sort Formats to get fixed order of Formats after compilation.
-  Formats.Sort();
   return S_OK;
 }
 
-#ifndef Z7_SFX
+#ifndef _SFX
 
 int CCodecs::FindFormatForArchiveName(const UString &arcPath) const
 {
   int dotPos = arcPath.ReverseFind_Dot();
   if (dotPos <= arcPath.ReverseFind_PathSepar())
     return -1;
-  const UString ext = arcPath.Ptr((unsigned)(dotPos + 1));
+  const UString ext = arcPath.Ptr(dotPos + 1);
   if (ext.IsEmpty())
     return -1;
   if (ext.IsEqualTo_Ascii_NoCase("exe"))
@@ -897,7 +692,7 @@ int CCodecs::FindFormatForArchiveName(const UString &arcPath) const
       continue;
     */
     if (arc.FindExtension(ext) >= 0)
-      return (int)i;
+      return i;
   }
   return -1;
 }
@@ -908,7 +703,7 @@ int CCodecs::FindFormatForExtension(const UString &ext) const
     return -1;
   FOR_VECTOR (i, Formats)
     if (Formats[i].FindExtension(ext) >= 0)
-      return (int)i;
+      return i;
   return -1;
 }
 
@@ -916,7 +711,7 @@ int CCodecs::FindFormatForArchiveType(const UString &arcType) const
 {
   FOR_VECTOR (i, Formats)
     if (Formats[i].Name.IsEqualTo_NoCase(arcType))
-      return (int)i;
+      return i;
   return -1;
 }
 
@@ -927,26 +722,76 @@ bool CCodecs::FindFormatForArchiveType(const UString &arcType, CIntVector &forma
   {
     int pos2 = arcType.Find(L'.', pos);
     if (pos2 < 0)
-      pos2 = (int)arcType.Len();
-    const UString name = arcType.Mid(pos, (unsigned)pos2 - pos);
+      pos2 = arcType.Len();
+    const UString name = arcType.Mid(pos, pos2 - pos);
     if (name.IsEmpty())
       return false;
-    const int index = FindFormatForArchiveType(name);
-    if (index < 0 && !name.IsEqualTo("*"))
+    int index = FindFormatForArchiveType(name);
+    if (index < 0 && name != L"*")
     {
       formatIndices.Clear();
       return false;
     }
     formatIndices.Add(index);
-    pos = (unsigned)pos2 + 1;
+    pos = pos2 + 1;
   }
   return true;
 }
 
-#endif // Z7_SFX
+#endif // _SFX
+
+
+#ifdef NEW_FOLDER_INTERFACE
+
+void CCodecIcons::LoadIcons(HMODULE m)
+{
+  UString iconTypes;
+  MyLoadString(m, kIconTypesResId, iconTypes);
+  UStringVector pairs;
+  SplitString(iconTypes, pairs);
+  FOR_VECTOR (i, pairs)
+  {
+    const UString &s = pairs[i];
+    int pos = s.Find(L':');
+    CIconPair iconPair;
+    iconPair.IconIndex = -1;
+    if (pos < 0)
+      pos = s.Len();
+    else
+    {
+      UString num = s.Ptr(pos + 1);
+      if (!num.IsEmpty())
+      {
+        const wchar_t *end;
+        iconPair.IconIndex = ConvertStringToUInt32(num, &end);
+        if (*end != 0)
+          continue;
+      }
+    }
+    iconPair.Ext = s.Left(pos);
+    IconPairs.Add(iconPair);
+  }
+}
+
+bool CCodecIcons::FindIconIndex(const UString &ext, int &iconIndex) const
+{
+  iconIndex = -1;
+  FOR_VECTOR (i, IconPairs)
+  {
+    const CIconPair &pair = IconPairs[i];
+    if (ext.IsEqualTo_NoCase(pair.Ext))
+    {
+      iconIndex = pair.IconIndex;
+      return true;
+    }
+  }
+  return false;
+}
+
+#endif // NEW_FOLDER_INTERFACE
 
 
-#ifdef Z7_EXTERNAL_CODECS
+#ifdef EXTERNAL_CODECS
 
 // #define EXPORT_CODECS
 
@@ -970,24 +815,24 @@ STDAPI GetHasherProp(UInt32 codecIndex, PROPID propID, PROPVARIANT *value);
 
 #endif // EXPORT_CODECS
 
-Z7_COM7F_IMF(CCodecs::GetNumMethods(UInt32 *numMethods))
+STDMETHODIMP CCodecs::GetNumMethods(UInt32 *numMethods)
 {
   *numMethods = NUM_EXPORT_CODECS
-    #ifdef Z7_EXTERNAL_CODECS
+    #ifdef EXTERNAL_CODECS
     + Codecs.Size()
     #endif
     ;
   return S_OK;
 }
 
-Z7_COM7F_IMF(CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   #ifdef EXPORT_CODECS
   if (index < g_NumCodecs)
     return GetMethodProperty(index, propID, value);
   #endif
 
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
 
   if (propID == NMethodPropID::kDecoderIsAssigned ||
@@ -1000,15 +845,6 @@ Z7_COM7F_IMF(CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *valu
     prop.Detach(value);
     return S_OK;
   }
- 
-  if (propID == NMethodPropID::kIsFilter && ci.IsFilter_Assigned)
-  {
-    NCOM::CPropVariant prop;
-    prop = (bool)ci.IsFilter;
-    prop.Detach(value);
-    return S_OK;
-  }
-
   const CCodecLib &lib = Libs[ci.LibIndex];
   return lib.GetMethodProperty(ci.CodecIndex, propID, value);
   #else
@@ -1016,14 +852,14 @@ Z7_COM7F_IMF(CCodecs::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *valu
   #endif
 }
 
-Z7_COM7F_IMF(CCodecs::CreateDecoder(UInt32 index, const GUID *iid, void **coder))
+STDMETHODIMP CCodecs::CreateDecoder(UInt32 index, const GUID *iid, void **coder)
 {
   #ifdef EXPORT_CODECS
   if (index < g_NumCodecs)
     return CreateDecoder(index, iid, coder);
   #endif
   
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
   if (ci.DecoderIsAssigned)
   {
@@ -1039,14 +875,14 @@ Z7_COM7F_IMF(CCodecs::CreateDecoder(UInt32 index, const GUID *iid, void **coder)
   #endif
 }
 
-Z7_COM7F_IMF(CCodecs::CreateEncoder(UInt32 index, const GUID *iid, void **coder))
+STDMETHODIMP CCodecs::CreateEncoder(UInt32 index, const GUID *iid, void **coder)
 {
   #ifdef EXPORT_CODECS
   if (index < g_NumCodecs)
     return CreateEncoder(index, iid, coder);
   #endif
 
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
   if (ci.EncoderIsAssigned)
   {
@@ -1063,23 +899,23 @@ Z7_COM7F_IMF(CCodecs::CreateEncoder(UInt32 index, const GUID *iid, void **coder)
 }
 
 
-Z7_COM7F_IMF2(UInt32, CCodecs::GetNumHashers())
+STDMETHODIMP_(UInt32) CCodecs::GetNumHashers()
 {
   return NUM_EXPORT_HASHERS
-    #ifdef Z7_EXTERNAL_CODECS
+    #ifdef EXTERNAL_CODECS
     + Hashers.Size()
     #endif
     ;
 }
 
-Z7_COM7F_IMF(CCodecs::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value))
+STDMETHODIMP CCodecs::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   #ifdef EXPORT_CODECS
   if (index < g_NumHashers)
     return ::GetHasherProp(index, propID, value);
   #endif
 
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
   return Libs[ci.LibIndex].ComHashers->GetHasherProp(ci.HasherIndex, propID, value);
   #else
@@ -1087,13 +923,13 @@ Z7_COM7F_IMF(CCodecs::GetHasherProp(UInt32 index, PROPID propID, PROPVARIANT *va
   #endif
 }
 
-Z7_COM7F_IMF(CCodecs::CreateHasher(UInt32 index, IHasher **hasher))
+STDMETHODIMP CCodecs::CreateHasher(UInt32 index, IHasher **hasher)
 {
   #ifdef EXPORT_CODECS
   if (index < g_NumHashers)
     return CreateHasher(index, hasher);
   #endif
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
   return Libs[ci.LibIndex].ComHashers->CreateHasher(ci.HasherIndex, hasher);
   #else
@@ -1108,9 +944,9 @@ int CCodecs::GetCodec_LibIndex(UInt32 index) const
     return -1;
   #endif
   
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllCodecInfo &ci = Codecs[index - NUM_EXPORT_CODECS];
-  return (int)ci.LibIndex;
+  return ci.LibIndex;
   #else
   return -1;
   #endif
@@ -1123,9 +959,9 @@ int CCodecs::GetHasherLibIndex(UInt32 index)
     return -1;
   #endif
   
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   const CDllHasherInfo &ci = Hashers[index - NUM_EXPORT_HASHERS];
-  return (int)ci.LibIndex;
+  return ci.LibIndex;
   #else
   return -1;
   #endif
@@ -1146,14 +982,13 @@ bool CCodecs::GetCodec_DecoderIsAssigned(UInt32 index) const
   }
   #endif
   
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   return Codecs[index - NUM_EXPORT_CODECS].DecoderIsAssigned;
   #else
   return false;
   #endif
 }
 
-
 bool CCodecs::GetCodec_EncoderIsAssigned(UInt32 index) const
 {
   #ifdef EXPORT_CODECS
@@ -1169,50 +1004,17 @@ bool CCodecs::GetCodec_EncoderIsAssigned(UInt32 index) const
   }
   #endif
   
-  #ifdef Z7_EXTERNAL_CODECS
+  #ifdef EXTERNAL_CODECS
   return Codecs[index - NUM_EXPORT_CODECS].EncoderIsAssigned;
   #else
   return false;
   #endif
 }
 
-
-bool CCodecs::GetCodec_IsFilter(UInt32 index, bool &isAssigned) const
-{
-  isAssigned = false;
-  #ifdef EXPORT_CODECS
-  if (index < g_NumCodecs)
-  {
-    NCOM::CPropVariant prop;
-    if (GetProperty(index, NMethodPropID::kIsFilter, &prop) == S_OK)
-    {
-      if (prop.vt == VT_BOOL)
-      {
-        isAssigned = true;
-        return VARIANT_BOOLToBool(prop.boolVal);
-      }
-    }
-    return false;
-  }
-  #endif
-  
-  #ifdef Z7_EXTERNAL_CODECS
-  {
-    const CDllCodecInfo &c = Codecs[index - NUM_EXPORT_CODECS];
-    isAssigned = c.IsFilter_Assigned;
-    return c.IsFilter;
-  }
-  #else
-  return false;
-  #endif
-}
-
-
 UInt32 CCodecs::GetCodec_NumStreams(UInt32 index)
 {
   NCOM::CPropVariant prop;
-  if (GetProperty(index, NMethodPropID::kPackStreams, &prop) != S_OK)
-    return 0;
+  RINOK(GetProperty(index, NMethodPropID::kPackStreams, &prop));
   if (prop.vt == VT_UI4)
     return (UInt32)prop.ulVal;
   if (prop.vt == VT_EMPTY)
@@ -1223,7 +1025,7 @@ UInt32 CCodecs::GetCodec_NumStreams(UInt32 index)
 HRESULT CCodecs::GetCodec_Id(UInt32 index, UInt64 &id)
 {
   NCOM::CPropVariant prop;
-  RINOK(GetProperty(index, NMethodPropID::kID, &prop))
+  RINOK(GetProperty(index, NMethodPropID::kID, &prop));
   if (prop.vt != VT_UI8)
     return E_INVALIDARG;
   id = prop.uhVal.QuadPart;
@@ -1263,75 +1065,10 @@ AString CCodecs::GetHasherName(UInt32 index)
 UInt32 CCodecs::GetHasherDigestSize(UInt32 index)
 {
   NCOM::CPropVariant prop;
-  if (GetHasherProp(index, NMethodPropID::kDigestSize, &prop) != S_OK)
-    return 0;
+  RINOK(GetHasherProp(index, NMethodPropID::kDigestSize, &prop));
   if (prop.vt != VT_UI4)
     return 0;
   return prop.ulVal;
 }
 
-void CCodecs::GetCodecsErrorMessage(UString &s)
-{
-  s.Empty();
-  FOR_VECTOR (i, Errors)
-  {
-    const CCodecError &ce = Errors[i];
-    s += "Codec Load Error: ";
-    s += fs2us(ce.Path);
-    if (ce.ErrorCode != 0)
-    {
-      s += " : ";
-      s += NWindows::NError::MyFormatMessage(ce.ErrorCode);
-    }
-    if (!ce.Message.IsEmpty())
-    {
-      s += " : ";
-      s += ce.Message;
-    }
-    s.Add_LF();
-  }
-}
-
-#endif // Z7_EXTERNAL_CODECS
-
-#ifndef Z7_SFX
-
-extern unsigned g_NumCodecs;
-extern const CCodecInfo *g_Codecs[];
-
-void CCodecs::Get_CodecsInfoUser_Vector(CObjectVector<CCodecInfoUser> &v)
-{
-  v.Clear();
-  {
-    for (unsigned i = 0; i < g_NumCodecs; i++)
-    {
-      const CCodecInfo &cod = *g_Codecs[i];
-      CCodecInfoUser &u = v.AddNew();
-      u.EncoderIsAssigned = (cod.CreateEncoder != NULL);
-      u.DecoderIsAssigned = (cod.CreateDecoder != NULL);
-      u.IsFilter_Assigned = true;
-      u.IsFilter = cod.IsFilter;
-      u.NumStreams = cod.NumStreams;
-      u.Name = cod.Name;
-    }
-  }
-
-
-  #ifdef Z7_EXTERNAL_CODECS
-  {
-    UInt32 numMethods;
-    if (GetNumMethods(&numMethods) == S_OK)
-    for (UInt32 j = 0; j < numMethods; j++)
-    {
-      CCodecInfoUser &u = v.AddNew();
-      u.EncoderIsAssigned = GetCodec_EncoderIsAssigned(j);
-      u.DecoderIsAssigned = GetCodec_DecoderIsAssigned(j);
-      u.IsFilter = GetCodec_IsFilter(j, u.IsFilter_Assigned);
-      u.NumStreams = GetCodec_NumStreams(j);
-      u.Name = GetCodec_Name(j);
-    }
-  }
-  #endif
-}
-
-#endif
+#endif // EXTERNAL_CODECS