seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/Zip/ZipHandlerOut.cpp

@@ -2,12 +2,12 @@
 
 #include "StdAfx.h"
 
-#include "Common/ComTry.h"
-#include "Common/StringConvert.h"
-#include "Common/StringToInt.h"
+#include "../../../Common/ComTry.h"
+#include "../../../Common/StringConvert.h"
+#include "../../../Common/StringToInt.h"
 
-#include "Windows/PropVariant.h"
-#include "Windows/Time.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
 
 #include "../../IPassword.h"
 
@@ -28,52 +28,22 @@ using namespace NTime;
 namespace NArchive {
 namespace NZip {
 
-static const UInt32 kLzAlgoX1 = 0;
-static const UInt32 kLzAlgoX5 = 1;
-
-static const UInt32 kDeflateNumPassesX1  = 1;
-static const UInt32 kDeflateNumPassesX7  = 3;
-static const UInt32 kDeflateNumPassesX9  = 10;
-
-static const UInt32 kDeflateNumFastBytesX1 = 32;
-static const UInt32 kDeflateNumFastBytesX7 = 64;
-static const UInt32 kDeflateNumFastBytesX9 = 128;
-
-static const wchar_t *kLzmaMatchFinderX1 = L"HC4";
-static const wchar_t *kLzmaMatchFinderX5 = L"BT4";
-
-static const UInt32 kLzmaNumFastBytesX1 = 32;
-static const UInt32 kLzmaNumFastBytesX7 = 64;
-
-static const UInt32 kLzmaDicSizeX1 = 1 << 16;
-static const UInt32 kLzmaDicSizeX3 = 1 << 20;
-static const UInt32 kLzmaDicSizeX5 = 1 << 24;
-static const UInt32 kLzmaDicSizeX7 = 1 << 25;
-static const UInt32 kLzmaDicSizeX9 = 1 << 26;
-
-static const UInt32 kBZip2NumPassesX1 = 1;
-static const UInt32 kBZip2NumPassesX7 = 2;
-static const UInt32 kBZip2NumPassesX9 = 7;
-
-static const UInt32 kBZip2DicSizeX1 = 100000;
-static const UInt32 kBZip2DicSizeX3 = 500000;
-static const UInt32 kBZip2DicSizeX5 = 900000;
-
 STDMETHODIMP CHandler::GetFileTimeType(UInt32 *timeType)
 {
   *timeType = NFileTimeType::kDOS;
   return S_OK;
 }
 
-static bool IsAsciiString(const UString &s)
+static bool IsSimpleAsciiString(const wchar_t *s)
 {
-  for (int i = 0; i < s.Length(); i++)
+  for (;;)
   {
-    wchar_t c = s[i];
+    wchar_t c = *s++;
+    if (c == 0)
+      return true;
     if (c < 0x20 || c > 0x7F)
       return false;
   }
-  return true;
 }
 
 #define COM_TRY_BEGIN2 try {
@@ -97,38 +67,48 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     IArchiveUpdateCallback *callback)
 {
   COM_TRY_BEGIN2
+  
+  if (m_Archive.IsOpen())
+  {
+    if (!m_Archive.CanUpdate())
+      return E_NOTIMPL;
+  }
+
   CObjectVector<CUpdateItem> updateItems;
   bool thereAreAesUpdates = false;
+  UInt64 largestSize = 0;
+  bool largestSizeDefined = false;
+
   for (UInt32 i = 0; i < numItems; i++)
   {
     CUpdateItem ui;
     Int32 newData;
-    Int32 newProperties;
+    Int32 newProps;
     UInt32 indexInArchive;
     if (!callback)
       return E_FAIL;
-    RINOK(callback->GetUpdateItemInfo(i, &newData, &newProperties, &indexInArchive));
-    ui.NewProperties = IntToBool(newProperties);
+    RINOK(callback->GetUpdateItemInfo(i, &newData, &newProps, &indexInArchive));
+    ui.NewProps = IntToBool(newProps);
     ui.NewData = IntToBool(newData);
-    ui.IndexInArchive = indexInArchive;
+    ui.IndexInArc = indexInArchive;
     ui.IndexInClient = i;
-    bool existInArchive = (indexInArchive != (UInt32)-1);
+    bool existInArchive = (indexInArchive != (UInt32)(Int32)-1);
     if (existInArchive && newData)
       if (m_Items[indexInArchive].IsAesEncrypted())
         thereAreAesUpdates = true;
 
-    if (IntToBool(newProperties))
+    if (IntToBool(newProps))
     {
       UString name;
       {
         NCOM::CPropVariant prop;
         RINOK(callback->GetProperty(i, kpidAttrib, &prop));
         if (prop.vt == VT_EMPTY)
-          ui.Attributes = 0;
+          ui.Attrib = 0;
         else if (prop.vt != VT_UI4)
           return E_INVALIDARG;
         else
-          ui.Attributes = prop.ulVal;
+          ui.Attrib = prop.ulVal;
       }
 
       {
@@ -160,15 +140,15 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
         else
           ui.NtfsTimeIsDefined = m_WriteNtfsTimeExtra;
       }
-      RINOK(GetTime(callback, i, kpidMTime, ui.NtfsMTime));
-      RINOK(GetTime(callback, i, kpidATime, ui.NtfsATime));
-      RINOK(GetTime(callback, i, kpidCTime, ui.NtfsCTime));
+      RINOK(GetTime(callback, i, kpidMTime, ui.Ntfs_MTime));
+      RINOK(GetTime(callback, i, kpidATime, ui.Ntfs_ATime));
+      RINOK(GetTime(callback, i, kpidCTime, ui.Ntfs_CTime));
 
       {
         FILETIME localFileTime = { 0, 0 };
-        if (ui.NtfsMTime.dwHighDateTime != 0 ||
-            ui.NtfsMTime.dwLowDateTime != 0)
-          if (!FileTimeToLocalFileTime(&ui.NtfsMTime, &localFileTime))
+        if (ui.Ntfs_MTime.dwHighDateTime != 0 ||
+            ui.Ntfs_MTime.dwLowDateTime != 0)
+          if (!FileTimeToLocalFileTime(&ui.Ntfs_MTime, &localFileTime))
             return E_INVALIDARG;
         FileTimeToDosTime(localFileTime, ui.Time);
       }
@@ -178,7 +158,7 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       const wchar_t kSlash = L'/';
       if (!name.IsEmpty())
       {
-        if (name[name.Length() - 1] == kSlash)
+        if (name.Back() == kSlash)
         {
           if (!ui.IsDir)
             return E_INVALIDARG;
@@ -188,14 +168,16 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
       if (needSlash)
         name += kSlash;
 
+      UINT codePage = _forceCodePage ? _specifiedCodePage : CP_OEMCP;
+
       bool tryUtf8 = true;
-      if (m_ForceLocal || !m_ForceUtf8)
+      if ((m_ForceLocal || !m_ForceUtf8) && codePage != CP_UTF8)
       {
 #ifdef _WIN32
         bool defaultCharWasUsed;
-        ui.Name = UnicodeStringToMultiByte(name, CP_OEMCP, '_', defaultCharWasUsed);
+        ui.Name = UnicodeStringToMultiByte(name, codePage, '_', defaultCharWasUsed);
         tryUtf8 = (!m_ForceLocal && (defaultCharWasUsed ||
-          MultiByteToUnicodeString(ui.Name, CP_OEMCP) != name));
+          MultiByteToUnicodeString(ui.Name, codePage) != name));
 #else
 	// FIXME
         ui.Name = UnicodeStringToMultiByte(name, CP_OEMCP);
@@ -205,14 +187,11 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
 
       if (tryUtf8)
       {
-        int i;
-        for (i = 0; i < name.Length() && (unsigned)name[i] < 0x80; i++);
-        ui.IsUtf8 = (i != name.Length());
-        if (!ConvertUnicodeToUTF8(name, ui.Name))
-          return E_INVALIDARG;
+        ui.IsUtf8 = !name.IsAscii();
+        ConvertUnicodeToUTF8(name, ui.Name);
       }
 
-      if (ui.Name.Length() >= (1 << 16))
+      if (ui.Name.Len() >= (1 << 16))
         return E_INVALIDARG;
 
       ui.IndexInClient = i;
@@ -234,15 +213,21 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     }
     if (IntToBool(newData))
     {
-      UInt64 size;
+      UInt64 size = 0;
+      if (!ui.IsDir)
       {
         NCOM::CPropVariant prop;
         RINOK(callback->GetProperty(i, kpidSize, &prop));
         if (prop.vt != VT_UI8)
           return E_INVALIDARG;
         size = prop.uhVal.QuadPart;
+        if (largestSize < size)
+          largestSize = size;
+        largestSizeDefined = true;
       }
       ui.Size = size;
+
+      // ui.Size -= ui.Size / 2;
     }
     updateItems.Add(ui);
   }
@@ -253,7 +238,12 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     udateCallBack2.QueryInterface(IID_ICryptoGetTextPassword2, &getTextPassword);
   }
   CCompressionMethodMode options;
+  (CBaseProps &)options = _props;
+  options._dataSizeReduce = largestSize;
+  options._dataSizeReduceDefined = largestSizeDefined;
 
+  options.PasswordIsDefined = false;
+  options.Password.Empty();
   if (getTextPassword)
   {
     CMyComBSTR password;
@@ -262,29 +252,24 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
     options.PasswordIsDefined = IntToBool(passwordIsDefined);
     if (options.PasswordIsDefined)
     {
-      options.IsAesMode = (m_ForceAesMode ? m_IsAesMode : thereAreAesUpdates);
-      options.AesKeyMode = m_AesKeyMode;
+      if (!m_ForceAesMode)
+        options.IsAesMode = thereAreAesUpdates;
 
-      if (!IsAsciiString((const wchar_t *)password))
+      if (!IsSimpleAsciiString(password))
         return E_INVALIDARG;
+      if (password)
+        options.Password = UnicodeStringToMultiByte((LPCOLESTR)password, CP_OEMCP);
       if (options.IsAesMode)
       {
-        if (options.Password.Length() > NCrypto::NWzAes::kPasswordSizeMax)
+        if (options.Password.Len() > NCrypto::NWzAes::kPasswordSizeMax)
           return E_INVALIDARG;
       }
-      options.Password = UnicodeStringToMultiByte((const wchar_t *)password, CP_OEMCP);
     }
   }
-  else
-    options.PasswordIsDefined = false;
 
-  int level = m_Level;
-  if (level < 0)
-    level = 5;
-  
   Byte mainMethod;
   if (m_MainMethod < 0)
-    mainMethod = (Byte)(((level == 0) ?
+    mainMethod = (Byte)(((_props.Level == 0) ?
         NFileHeader::NCompressionMethod::kStored :
         NFileHeader::NCompressionMethod::kDeflated));
   else
@@ -292,244 +277,170 @@ STDMETHODIMP CHandler::UpdateItems(ISequentialOutStream *outStream, UInt32 numIt
   options.MethodSequence.Add(mainMethod);
   if (mainMethod != NFileHeader::NCompressionMethod::kStored)
     options.MethodSequence.Add(NFileHeader::NCompressionMethod::kStored);
-  bool isDeflate = (mainMethod == NFileHeader::NCompressionMethod::kDeflated) ||
-      (mainMethod == NFileHeader::NCompressionMethod::kDeflated64);
-  bool isLZMA = (mainMethod == NFileHeader::NCompressionMethod::kLZMA);
-  bool isLz = (isLZMA || isDeflate);
-  options.NumPasses = m_NumPasses;
-  options.DicSize = m_DicSize;
-  options.NumFastBytes = m_NumFastBytes;
-  options.NumMatchFinderCycles = m_NumMatchFinderCycles;
-  options.NumMatchFinderCyclesDefined = m_NumMatchFinderCyclesDefined;
-  options.Algo = m_Algo;
-  options.MemSize = m_MemSize;
-  options.Order = m_Order;
-  #ifndef _7ZIP_ST
-  options.NumThreads = _numThreads;
-  #endif
-  if (isLz)
-  {
-    if (isDeflate)
-    {
-      if (options.NumPasses == 0xFFFFFFFF)
-        options.NumPasses = (level >= 9 ? kDeflateNumPassesX9 :
-                            (level >= 7 ? kDeflateNumPassesX7 :
-                                          kDeflateNumPassesX1));
-      if (options.NumFastBytes == 0xFFFFFFFF)
-        options.NumFastBytes = (level >= 9 ? kDeflateNumFastBytesX9 :
-                               (level >= 7 ? kDeflateNumFastBytesX7 :
-                                             kDeflateNumFastBytesX1));
-    }
-    else if (isLZMA)
-    {
-      if (options.DicSize == 0xFFFFFFFF)
-        options.DicSize =
-          (level >= 9 ? kLzmaDicSizeX9 :
-          (level >= 7 ? kLzmaDicSizeX7 :
-          (level >= 5 ? kLzmaDicSizeX5 :
-          (level >= 3 ? kLzmaDicSizeX3 :
-                        kLzmaDicSizeX1))));
-
-      if (options.NumFastBytes == 0xFFFFFFFF)
-        options.NumFastBytes = (level >= 7 ? kLzmaNumFastBytesX7 :
-                                             kLzmaNumFastBytesX1);
-
-      options.MatchFinder =
-        (level >= 5 ? kLzmaMatchFinderX5 :
-                      kLzmaMatchFinderX1);
-    }
-
-    if (options.Algo == 0xFFFFFFFF)
-        options.Algo = (level >= 5 ? kLzAlgoX5 :
-                                     kLzAlgoX1);
-  }
-  if (mainMethod == NFileHeader::NCompressionMethod::kBZip2)
-  {
-    if (options.NumPasses == 0xFFFFFFFF)
-      options.NumPasses = (level >= 9 ? kBZip2NumPassesX9 :
-                          (level >= 7 ? kBZip2NumPassesX7 :
-                                        kBZip2NumPassesX1));
-    if (options.DicSize == 0xFFFFFFFF)
-      options.DicSize = (level >= 5 ? kBZip2DicSizeX5 :
-                        (level >= 3 ? kBZip2DicSizeX3 :
-                                      kBZip2DicSizeX1));
-  }
-  if (mainMethod == NFileHeader::NCompressionMethod::kPPMd)
-  {
-    int level2 = level;
-    if (level2 < 1) level2 = 1;
-    if (level2 > 9) level2 = 9;
-
-    if (options.MemSize == 0xFFFFFFFF)
-      options.MemSize = (1 << (19 + (level2 > 8 ? 8 : level2)));
-
-    if (options.Order == 0xFFFFFFFF)
-      options.Order = 3 + level2;
-
-    if (options.Algo == 0xFFFFFFFF)
-      options.Algo = (level2 >= 7 ? 1 : 0);
-  }
 
   return Update(
       EXTERNAL_CODECS_VARS
       m_Items, updateItems, outStream,
-      m_Archive.IsOpen() ? &m_Archive : NULL, &options, callback);
+      m_Archive.IsOpen() ? &m_Archive : NULL, _removeSfxBlock,
+      &options, callback);
+ 
   COM_TRY_END2
 }
 
-STDMETHODIMP CHandler::SetProperties(const wchar_t **names, const PROPVARIANT *values, Int32 numProperties)
+struct CMethodIndexToName
+{
+  unsigned Method;
+  const char *Name;
+};
+
+static const CMethodIndexToName k_SupportedMethods[] =
+{
+  { NFileHeader::NCompressionMethod::kStored, "copy" },
+  { NFileHeader::NCompressionMethod::kDeflated, "deflate" },
+  { NFileHeader::NCompressionMethod::kDeflated64, "deflate64" },
+  { NFileHeader::NCompressionMethod::kBZip2, "bzip2" },
+  { NFileHeader::NCompressionMethod::kLZMA, "lzma" },
+  { NFileHeader::NCompressionMethod::kPPMd, "ppmd" }
+};
+
+STDMETHODIMP CHandler::SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps)
 {
+  InitMethodProps();
   #ifndef _7ZIP_ST
-  const UInt32 numProcessors = NSystem::GetNumberOfProcessors();
-  _numThreads = numProcessors;
+  const UInt32 numProcessors = _props.NumThreads;
   #endif
-  InitMethodProperties();
-  for (int i = 0; i < numProperties; i++)
+  
+  for (UInt32 i = 0; i < numProps; i++)
   {
-    UString name = UString(names[i]);
-    name.MakeUpper();
+    UString name = names[i];
+    name.MakeLower_Ascii();
     if (name.IsEmpty())
       return E_INVALIDARG;
 
     const PROPVARIANT &prop = values[i];
 
-    if (name[0] == L'X')
+    if (name[0] == L'x')
     {
       UInt32 level = 9;
-      RINOK(ParsePropValue(name.Mid(1), prop, level));
-      m_Level = level;
-      continue;
+      RINOK(ParsePropToUInt32(name.Ptr(1), prop, level));
+      _props.Level = level;
+      _props.MethodInfo.AddProp_Level(level);
     }
-    else if (name == L"M")
+    else if (name == L"m")
     {
       if (prop.vt == VT_BSTR)
       {
-        UString m = prop.bstrVal;
-        m.MakeUpper();
-        if (m == L"COPY") m_MainMethod = NFileHeader::NCompressionMethod::kStored;
-        else if (m == L"DEFLATE") m_MainMethod = NFileHeader::NCompressionMethod::kDeflated;
-        else if (m == L"DEFLATE64") m_MainMethod = NFileHeader::NCompressionMethod::kDeflated64;
-        else if (m == L"BZIP2") m_MainMethod = NFileHeader::NCompressionMethod::kBZip2;
-        else if (m == L"LZMA") m_MainMethod = NFileHeader::NCompressionMethod::kLZMA;
-        else if (m == L"PPMD") m_MainMethod = NFileHeader::NCompressionMethod::kPPMd;
-        else return E_INVALIDARG;
+        UString m = prop.bstrVal, m2;
+        m.MakeLower_Ascii();
+        int colonPos = m.Find(L':');
+        if (colonPos >= 0)
+        {
+          m2 = m.Ptr(colonPos + 1);
+          m.DeleteFrom(colonPos);
+        }
+        unsigned k;
+        for (k = 0; k < ARRAY_SIZE(k_SupportedMethods); k++)
+        {
+          const CMethodIndexToName &pair = k_SupportedMethods[k];
+          if (m.IsEqualTo(pair.Name))
+          {
+            if (!m2.IsEmpty())
+            {
+              RINOK(_props.MethodInfo.ParseParamsFromString(m2));
+            }
+            m_MainMethod = pair.Method;
+            break;
+          }
+        }
+        if (k == ARRAY_SIZE(k_SupportedMethods))
+          return E_INVALIDARG;
       }
       else if (prop.vt == VT_UI4)
       {
-        switch(prop.ulVal)
+        unsigned k;
+        for (k = 0; k < ARRAY_SIZE(k_SupportedMethods); k++)
         {
-          case NFileHeader::NCompressionMethod::kStored:
-          case NFileHeader::NCompressionMethod::kDeflated:
-          case NFileHeader::NCompressionMethod::kDeflated64:
-          case NFileHeader::NCompressionMethod::kBZip2:
-          case NFileHeader::NCompressionMethod::kLZMA:
-            m_MainMethod = (Byte)prop.ulVal;
+          unsigned method = k_SupportedMethods[k].Method;
+          if (prop.ulVal == method)
+          {
+            m_MainMethod = method;
             break;
-          default:
-            return E_INVALIDARG;
+          }
         }
+        if (k == ARRAY_SIZE(k_SupportedMethods))
+          return E_INVALIDARG;
       }
       else
         return E_INVALIDARG;
     }
-    else if (name.Left(2) == L"EM")
+    else if (name.IsPrefixedBy(L"em"))
     {
-      if (prop.vt == VT_BSTR)
+      if (prop.vt != VT_BSTR)
+        return E_INVALIDARG;
       {
-        UString valueString = prop.bstrVal;
-        valueString.MakeUpper();
-        if (valueString.Left(3) == L"AES")
+        UString m = prop.bstrVal;
+        m.MakeLower_Ascii();
+        if (m.IsPrefixedBy(L"aes"))
         {
-          valueString = valueString.Mid(3);
-          if (valueString == L"128")
-            m_AesKeyMode = 1;
-          else if (valueString == L"192")
-            m_AesKeyMode = 2;
-          else if (valueString == L"256" || valueString.IsEmpty())
-            m_AesKeyMode = 3;
+          m.DeleteFrontal(3);
+          if (m == L"128")
+            _props.AesKeyMode = 1;
+          else if (m == L"192")
+            _props.AesKeyMode = 2;
+          else if (m == L"256" || m.IsEmpty())
+            _props.AesKeyMode = 3;
           else
             return E_INVALIDARG;
-          m_IsAesMode = true;
+          _props.IsAesMode = true;
           m_ForceAesMode = true;
         }
-        else if (valueString == L"ZIPCRYPTO")
+        else if (m == L"zipcrypto")
         {
-          m_IsAesMode = false;
+          _props.IsAesMode = false;
           m_ForceAesMode = true;
         }
         else
           return E_INVALIDARG;
       }
-      else
-        return E_INVALIDARG;
-    }
-    else if (name[0] == L'D')
-    {
-      UInt32 dicSize = kBZip2DicSizeX5;
-      RINOK(ParsePropDictionaryValue(name.Mid(1), prop, dicSize));
-      m_DicSize = dicSize;
-    }
-    else if (name.Left(3) == L"MEM")
-    {
-      UInt32 memSize = 1 << 24;
-      RINOK(ParsePropDictionaryValue(name.Mid(3), prop, memSize));
-      m_MemSize = memSize;
-    }
-    else if (name[0] == L'O')
-    {
-      UInt32 order = 8;
-      RINOK(ParsePropValue(name.Mid(1), prop, order));
-      m_Order = order;
-    }
-    else if (name.Left(4) == L"PASS")
-    {
-      UInt32 num = kDeflateNumPassesX9;
-      RINOK(ParsePropValue(name.Mid(4), prop, num));
-      m_NumPasses = num;
-    }
-    else if (name.Left(2) == L"FB")
-    {
-      UInt32 num = kDeflateNumFastBytesX9;
-      RINOK(ParsePropValue(name.Mid(2), prop, num));
-      m_NumFastBytes = num;
-    }
-    else if (name.Left(2) == L"MC")
-    {
-      UInt32 num = 0xFFFFFFFF;
-      RINOK(ParsePropValue(name.Mid(2), prop, num));
-      m_NumMatchFinderCycles = num;
-      m_NumMatchFinderCyclesDefined = true;
     }
-    else if (name.Left(2) == L"MT")
+    else if (name.IsPrefixedBy(L"mt"))
     {
       #ifndef _7ZIP_ST
-      RINOK(ParseMtProp(name.Mid(2), prop, numProcessors, _numThreads));
+      RINOK(ParseMtProp(name.Ptr(2), prop, numProcessors, _props.NumThreads));
+      _props.NumThreadsWasChanged = true;
       #endif
     }
-    else if (name.Left(1) == L"A")
+    else if (name.IsEqualTo("tc"))
     {
-      UInt32 num = kLzAlgoX5;
-      RINOK(ParsePropValue(name.Mid(1), prop, num));
-      m_Algo = num;
+      RINOK(PROPVARIANT_to_bool(prop, m_WriteNtfsTimeExtra));
     }
-    else if (name.CompareNoCase(L"TC") == 0)
+    else if (name.IsEqualTo("cl"))
     {
-      RINOK(SetBoolProperty(m_WriteNtfsTimeExtra, prop));
-    }
-    else if (name.CompareNoCase(L"CL") == 0)
-    {
-      RINOK(SetBoolProperty(m_ForceLocal, prop));
+      RINOK(PROPVARIANT_to_bool(prop, m_ForceLocal));
       if (m_ForceLocal)
         m_ForceUtf8 = false;
     }
-    else if (name.CompareNoCase(L"CU") == 0)
+    else if (name.IsEqualTo("cu"))
     {
-      RINOK(SetBoolProperty(m_ForceUtf8, prop));
+      RINOK(PROPVARIANT_to_bool(prop, m_ForceUtf8));
       if (m_ForceUtf8)
         m_ForceLocal = false;
     }
+    else if (name.IsEqualTo("cp"))
+    {
+      UInt32 cp = CP_OEMCP;
+      RINOK(ParsePropToUInt32(L"", prop, cp));
+      _forceCodePage = true;
+      _specifiedCodePage = cp;
+    }
+    else if (name.IsEqualTo("rsfx"))
+    {
+      RINOK(PROPVARIANT_to_bool(prop, _removeSfxBlock));
+    }
     else
-      return E_INVALIDARG;
+    {
+      RINOK(_props.MethodInfo.ParseParamsFromPROPVARIANT(name, prop));
+    }
   }
   return S_OK;
 }