seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/Windows/FileName.h

@@ -3,7 +3,7 @@
 #ifndef __WINDOWS_FILENAME_H
 #define __WINDOWS_FILENAME_H
 
-#include "../../C/Types.h"
+#include "../../C/7zTypes.h"
 
 #include "../Common/MyString.h"
 
@@ -11,6 +11,11 @@ namespace NWindows {
 namespace NFile {
 namespace NName {
 
+int FindSepar(const wchar_t *s) throw();
+#ifndef USE_UNICODE_FSTRING
+int FindSepar(const FChar *s) throw();
+#endif
+
 const TCHAR kDirDelimiter = CHAR_PATH_SEPARATOR;
 const TCHAR kAnyStringWildcard = '*';
 
@@ -19,8 +24,11 @@ void NormalizeDirPathPrefix(CSysString &dirPath); // ensures that it ended with
 void NormalizeDirPathPrefix(UString &dirPath); // ensures that it ended with '\\'
 #endif
 
-void SplitNameToPureNameAndExtension(const UString &fullName,
-    UString &pureName, UString &extensionDelimiter, UString &extension);
+bool IsAbsolutePath(const wchar_t *s) throw();
+unsigned GetRootPrefixSize(const wchar_t *s) throw();
+
+bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
+bool GetFullPath(CFSTR path, FString &fullPath);
 
 }}}
 

data/ext/p7zip/CPP/Windows/NtCheck.h

@@ -5,6 +5,8 @@
 
 #ifdef _WIN32
 
+#include "../Common/MyWindows.h"
+
 #if !defined(_WIN64) && !defined(UNDER_CE)
 static inline bool IsItWindowsNT()
 {

data/ext/p7zip/CPP/Windows/PropVariant.cpp

@@ -2,13 +2,53 @@
 
 #include "StdAfx.h"
 
-#include "PropVariant.h"
-
 #include "../Common/Defs.h"
 
+#include "PropVariant.h"
+
 namespace NWindows {
 namespace NCOM {
 
+BSTR AllocBstrFromAscii(const char *s) throw()
+{
+  if (!s)
+    return NULL;
+  UINT len = (UINT)strlen(s);
+  BSTR p = ::SysAllocStringLen(NULL, len);
+  if (p)
+  {
+    for (UINT i = 0; i <= len; i++)
+      p[i] = (Byte)s[i];
+  }
+  return p;
+}
+
+HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
+{
+  p->bstrVal = ::SysAllocStringLen(NULL, numChars);
+  if (!p->bstrVal)
+  {
+    p->vt = VT_ERROR;
+    p->scode = E_OUTOFMEMORY;
+    return E_OUTOFMEMORY;
+  }
+  p->vt = VT_BSTR;
+  return S_OK;
+}
+
+HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
+{
+  p->bstrVal = AllocBstrFromAscii(s);
+  if (p->bstrVal)
+  {
+    p->vt = VT_BSTR;
+    return S_OK;
+  }
+  p->vt = VT_ERROR;
+  p->scode = E_OUTOFMEMORY;
+  return E_OUTOFMEMORY;
+}
+
 CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
 {
   vt = VT_EMPTY;
@@ -38,6 +78,7 @@ CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
   InternalCopy(&varSrc);
   return *this;
 }
+
 CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
 {
   InternalCopy(&varSrc);
@@ -58,7 +99,7 @@ CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
   vt = VT_BSTR;
   wReserved1 = 0;
   bstrVal = ::SysAllocString(lpszSrc);
-  if (bstrVal == NULL && lpszSrc != NULL)
+  if (!bstrVal && lpszSrc)
   {
     throw kMemException;
     // vt = VT_ERROR;
@@ -67,29 +108,64 @@ CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
   return *this;
 }
 
+CPropVariant& CPropVariant::operator=(const UString &s)
+{
+  InternalClear();
+  vt = VT_BSTR;
+  wReserved1 = 0;
+  bstrVal = ::SysAllocStringLen(s, s.Len());
+  if (!bstrVal)
+    throw kMemException;
+  return *this;
+}
+
+CPropVariant& CPropVariant::operator=(const UString2 &s)
+{
+  /*
+  if (s.IsEmpty())
+    *this = L"";
+  else
+  */
+  {
+    InternalClear();
+    vt = VT_BSTR;
+    wReserved1 = 0;
+    bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
+    if (!bstrVal)
+      throw kMemException;
+    /* SysAllocStringLen probably appends a null-terminating character for NULL string.
+       But it doesn't specified in MSDN.
+       But we suppose that it works
+
+    if (!s.GetRawPtr())
+    {
+      *bstrVal = 0;
+    }
+    */
+
+    /* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
+                         pointers to this function causes  an unexpected termination of the application.
+       Is it safe? Maybe we must chamnge the code for that case ? */
+  }
+  return *this;
+}
 
 CPropVariant& CPropVariant::operator=(const char *s)
 {
   InternalClear();
   vt = VT_BSTR;
   wReserved1 = 0;
-  UINT len = (UINT)strlen(s);
-  bstrVal = ::SysAllocStringByteLen(0, (UINT)len * sizeof(OLECHAR));
-  if (bstrVal == NULL)
+  bstrVal = AllocBstrFromAscii(s);
+  if (!bstrVal)
   {
     throw kMemException;
     // vt = VT_ERROR;
     // scode = E_OUTOFMEMORY;
   }
-  else
-  {
-    for (UINT i = 0; i <= len; i++)
-      bstrVal[i] = s[i];
-  }
   return *this;
 }
 
-CPropVariant& CPropVariant::operator=(bool bSrc)
+CPropVariant& CPropVariant::operator=(bool bSrc) throw()
 {
   if (vt != VT_BOOL)
   {
@@ -100,22 +176,40 @@ CPropVariant& CPropVariant::operator=(bool bSrc)
   return *this;
 }
 
+BSTR CPropVariant::AllocBstr(unsigned numChars)
+{
+  if (vt != VT_EMPTY)
+    InternalClear();
+  vt = VT_BSTR;
+  wReserved1 = 0;
+  bstrVal = ::SysAllocStringLen(NULL, numChars);
+  if (!bstrVal)
+  {
+    throw kMemException;
+    // vt = VT_ERROR;
+    // scode = E_OUTOFMEMORY;
+  }
+  return bstrVal;
+}
+
 #define SET_PROP_FUNC(type, id, dest) \
-  CPropVariant& CPropVariant::operator=(type value) \
+  CPropVariant& CPropVariant::operator=(type value) throw() \
   { if (vt != id) { InternalClear(); vt = id; } \
     dest = value; return *this; }
 
 SET_PROP_FUNC(Byte, VT_UI1, bVal)
-SET_PROP_FUNC(Int16, VT_I2, iVal)
+// SET_PROP_FUNC(Int16, VT_I2, iVal)
 SET_PROP_FUNC(Int32, VT_I4, lVal)
 SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
 SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
+SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
 SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
 
-static HRESULT MyPropVariantClear(PROPVARIANT *prop)
+HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
 {
-  switch(prop->vt)
+  switch (prop->vt)
   {
+    case VT_EMPTY:
     case VT_UI1:
     case VT_I1:
     case VT_I2:
@@ -134,20 +228,27 @@ static HRESULT MyPropVariantClear(PROPVARIANT *prop)
     case VT_DATE:
       prop->vt = VT_EMPTY;
       prop->wReserved1 = 0;
+      prop->wReserved2 = 0;
+      prop->wReserved3 = 0;
+      prop->uhVal.QuadPart = 0;
       return S_OK;
   }
   return ::VariantClear((VARIANTARG *)prop);
+  // return ::PropVariantClear(prop);
+  // PropVariantClear can clear VT_BLOB.
 }
 
-HRESULT CPropVariant::Clear()
+HRESULT CPropVariant::Clear() throw()
 {
-  return MyPropVariantClear(this);
+  if (vt == VT_EMPTY)
+    return S_OK;
+  return PropVariant_Clear(this);
 }
 
-HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc)
+HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
 {
   ::VariantClear((tagVARIANT *)this);
-  switch(pSrc->vt)
+  switch (pSrc->vt)
   {
     case VT_UI1:
     case VT_I1:
@@ -172,7 +273,7 @@ HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc)
 }
 
 
-HRESULT CPropVariant::Attach(PROPVARIANT *pSrc)
+HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
 {
   HRESULT hr = Clear();
   if (FAILED(hr))
@@ -182,18 +283,23 @@ HRESULT CPropVariant::Attach(PROPVARIANT *pSrc)
   return S_OK;
 }
 
-HRESULT CPropVariant::Detach(PROPVARIANT *pDest)
+HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
 {
-  HRESULT hr = MyPropVariantClear(pDest);
-  if (FAILED(hr))
-    return hr;
+  if (pDest->vt != VT_EMPTY)
+  {
+    HRESULT hr = PropVariant_Clear(pDest);
+    if (FAILED(hr))
+      return hr;
+  }
   memcpy(pDest, this, sizeof(PROPVARIANT));
   vt = VT_EMPTY;
   return S_OK;
 }
 
-HRESULT CPropVariant::InternalClear()
+HRESULT CPropVariant::InternalClear() throw()
 {
+  if (vt == VT_EMPTY)
+    return S_OK;
   HRESULT hr = Clear();
   if (FAILED(hr))
   {
@@ -215,7 +321,7 @@ void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
   }
 }
 
-int CPropVariant::Compare(const CPropVariant &a)
+int CPropVariant::Compare(const CPropVariant &a) throw()
 {
   if (vt != a.vt)
     return MyCompare(vt, a.vt);
@@ -233,9 +339,7 @@ int CPropVariant::Compare(const CPropVariant &a)
     case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
     case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
     case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime);
-    case VT_BSTR:
-      return 0; // Not implemented
-      // return MyCompare(aPropVarint.cVal);
+    case VT_BSTR: return 0; // Not implemented
     default: return 0;
   }
 }

data/ext/p7zip/CPP/Windows/PropVariant.h

@@ -1,54 +1,110 @@
 // Windows/PropVariant.h
 
-#ifndef __WINDOWS_PROPVARIANT_H
-#define __WINDOWS_PROPVARIANT_H
+#ifndef __WINDOWS_PROP_VARIANT_H
+#define __WINDOWS_PROP_VARIANT_H
 
+#include "../Common/MyTypes.h"
 #include "../Common/MyWindows.h"
-#include "../Common/Types.h"
+#include "../Common/MyString.h"
 
 namespace NWindows {
 namespace NCOM {
 
+BSTR AllocBstrFromAscii(const char *s) throw();
+
+HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
+
+HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
+HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
+
+inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
+{
+  p->vt = VT_UI4;
+  p->ulVal = v;
+}
+
+inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
+{
+  p->vt = VT_UI8;
+  p->uhVal.QuadPart = v;
+}
+
+inline void PropVarEm_Set_FileTime64(PROPVARIANT *p, UInt64 v) throw()
+{
+  p->vt = VT_FILETIME;
+  p->filetime.dwLowDateTime = (DWORD)v;
+  p->filetime.dwHighDateTime = (DWORD)(v >> 32);
+}
+
+inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
+{
+  p->vt = VT_BOOL;
+  p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
+}
+
+
 class CPropVariant : public tagPROPVARIANT
 {
 public:
-  CPropVariant() { vt = VT_EMPTY; wReserved1 = 0; }
-  ~CPropVariant() { Clear(); }
+  CPropVariant()
+  {
+    vt = VT_EMPTY;
+    wReserved1 = 0;
+    // wReserved2 = 0;
+    // wReserved3 = 0;
+    // uhVal.QuadPart = 0;
+    bstrVal = 0;
+  }
+  ~CPropVariant() throw() { Clear(); }
   CPropVariant(const PROPVARIANT &varSrc);
   CPropVariant(const CPropVariant &varSrc);
   CPropVariant(BSTR bstrSrc);
   CPropVariant(LPCOLESTR lpszSrc);
-  CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); };
+  CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); }
   CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
-  CPropVariant(Int16 value) { vt = VT_I2; wReserved1 = 0; iVal = value; }
-  CPropVariant(Int32 value) { vt = VT_I4; wReserved1 = 0; lVal = value; }
+
+private:
+  CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
+  CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
+
+public:
   CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
   CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
+  CPropVariant(Int64 value) { vt = VT_I8; wReserved1 = 0; hVal.QuadPart = value; }
   CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
 
   CPropVariant& operator=(const CPropVariant &varSrc);
   CPropVariant& operator=(const PROPVARIANT &varSrc);
   CPropVariant& operator=(BSTR bstrSrc);
   CPropVariant& operator=(LPCOLESTR lpszSrc);
+  CPropVariant& operator=(const UString &s);
+  CPropVariant& operator=(const UString2 &s);
   CPropVariant& operator=(const char *s);
-  CPropVariant& operator=(bool bSrc);
-  CPropVariant& operator=(Byte value);
-  CPropVariant& operator=(Int16 value);
-  CPropVariant& operator=(Int32 value);
-  CPropVariant& operator=(UInt32 value);
-  CPropVariant& operator=(Int64 value);
-  CPropVariant& operator=(UInt64 value);
-  CPropVariant& operator=(const FILETIME &value);
-
-  HRESULT Clear();
-  HRESULT Copy(const PROPVARIANT *pSrc);
-  HRESULT Attach(PROPVARIANT *pSrc);
-  HRESULT Detach(PROPVARIANT *pDest);
-
-  HRESULT InternalClear();
+  
+  CPropVariant& operator=(bool bSrc) throw();
+  CPropVariant& operator=(Byte value) throw();
+  
+private:
+  CPropVariant& operator=(Int16 value) throw();
+
+public:
+  CPropVariant& operator=(Int32 value) throw();
+  CPropVariant& operator=(UInt32 value) throw();
+  CPropVariant& operator=(UInt64 value) throw();
+  CPropVariant& operator=(Int64 value) throw();
+  CPropVariant& operator=(const FILETIME &value) throw();
+
+  BSTR AllocBstr(unsigned numChars);
+
+  HRESULT Clear() throw();
+  HRESULT Copy(const PROPVARIANT *pSrc) throw();
+  HRESULT Attach(PROPVARIANT *pSrc) throw();
+  HRESULT Detach(PROPVARIANT *pDest) throw();
+
+  HRESULT InternalClear() throw();
   void InternalCopy(const PROPVARIANT *pSrc);
 
-  int Compare(const CPropVariant &a1);
+  int Compare(const CPropVariant &a) throw();
 };
 
 }}

data/ext/p7zip/CPP/Windows/PropVariantUtils.cpp

@@ -2,25 +2,22 @@
 
 #include "StdAfx.h"
 
+#include "../Common/IntToString.h"
+
 #include "PropVariantUtils.h"
-#include "Common/StringConvert.h"
-#include "Common/IntToString.h"
 
 using namespace NWindows;
 
 static AString GetHex(UInt32 v)
 {
-  char sz[32] = { '0', 'x' };
-  ConvertUInt64ToString(v, sz + 2, 16);
+  char sz[16];
+  sz[0] = '0';
+  sz[1] = 'x';
+  ConvertUInt32ToHex(v, sz + 2);
   return sz;
 }
 
-void StringToProp(const AString &s, NCOM::CPropVariant &prop)
-{
-  prop = MultiByteToUnicodeString(s);
-}
-
-void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
 {
   AString s;
   for (unsigned i = 0; i < num; i++)
@@ -31,22 +28,55 @@ void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM:
   }
   if (s.IsEmpty())
     s = GetHex(value);
-  StringToProp(s, prop);
+  return s;
 }
 
-AString TypeToString(const char *table[], unsigned num, UInt32 value)
+void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+{
+  prop = TypePairToString(pairs, num, value);
+}
+
+
+AString TypeToString(const char * const table[], unsigned num, UInt32 value)
 {
   if (value < num)
     return table[value];
   return GetHex(value);
 }
 
-void TypeToProp(const char *table[], unsigned num, UInt32 value, NCOM::CPropVariant &prop)
+void TypeToProp(const char * const table[], unsigned num, UInt32 value, NCOM::CPropVariant &prop)
 {
-  StringToProp(TypeToString(table, num, value), prop);
+  prop = TypeToString(table, num, value);
 }
 
 
+AString FlagsToString(const char * const *names, unsigned num, UInt32 flags)
+{
+  AString s;
+  for (unsigned i = 0; i < num; i++)
+  {
+    UInt32 flag = (UInt32)1 << i;
+    if ((flags & flag) != 0)
+    {
+      const char *name = names[i];
+      if (name != 0 && name[0] != 0)
+      {
+        if (!s.IsEmpty())
+          s += ' ';
+        s += name;
+        flags &= ~flag;
+      }
+    }
+  }
+  if (flags != 0)
+  {
+    if (!s.IsEmpty())
+      s += ' ';
+    s += GetHex(flags);
+  }
+  return s;
+}
+
 AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
 {
   AString s;
@@ -56,9 +86,12 @@ AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
     UInt32 flag = (UInt32)1 << (unsigned)p.Value;
     if ((flags & flag) != 0)
     {
-      if (!s.IsEmpty())
-        s += ' ';
-      s += p.Name;
+      if (p.Name[0] != 0)
+      {
+        if (!s.IsEmpty())
+          s += ' ';
+        s += p.Name;
+      }
     }
     flags &= ~flag;
   }
@@ -73,6 +106,44 @@ AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
 
 void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
 {
-  StringToProp(FlagsToString(pairs, num, flags), prop);
+  prop = FlagsToString(pairs, num, flags);
 }
 
+
+AString Flags64ToString(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags)
+{
+  AString s;
+  for (unsigned i = 0; i < num; i++)
+  {
+    const CUInt32PCharPair &p = pairs[i];
+    UInt64 flag = (UInt64)1 << (unsigned)p.Value;
+    if ((flags & flag) != 0)
+    {
+      if (p.Name[0] != 0)
+      {
+        if (!s.IsEmpty())
+          s += ' ';
+        s += p.Name;
+      }
+    }
+    flags &= ~flag;
+  }
+  if (flags != 0)
+  {
+    if (!s.IsEmpty())
+      s += ' ';
+    {
+      char sz[32];
+      sz[0] = '0';
+      sz[1] = 'x';
+      ConvertUInt64ToHex(flags, sz + 2);
+      s += sz;
+    }
+  }
+  return s;
+}
+
+void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NCOM::CPropVariant &prop)
+{
+  prop = Flags64ToString(pairs, num, flags);
+}

data/ext/p7zip/CPP/Windows/PropVariantUtils.h

@@ -3,7 +3,8 @@
 #ifndef __PROP_VARIANT_UTILS_H
 #define __PROP_VARIANT_UTILS_H
 
-#include "Common/MyString.h"
+#include "../Common/MyString.h"
+
 #include "PropVariant.h"
 
 struct CUInt32PCharPair
@@ -12,17 +13,21 @@ struct CUInt32PCharPair
   const char *Name;
 };
 
-void StringToProp(const AString &s, NWindows::NCOM::CPropVariant &prop);
+AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value);
 void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
 
+AString FlagsToString(const char * const *names, unsigned num, UInt32 flags);
 AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags);
 void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
 
-AString TypeToString(const char *table[], unsigned num, UInt32 value);
-void TypeToProp(const char *table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+AString TypeToString(const char * const table[], unsigned num, UInt32 value);
+void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
+
+#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, ARRAY_SIZE(pairs), value, prop)
+#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, ARRAY_SIZE(pairs), value, prop)
+#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, ARRAY_SIZE(table), value, prop)
 
-#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, sizeof(pairs) / sizeof(pairs[0]), value, prop)
-#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, sizeof(pairs) / sizeof(pairs[0]), value, prop)
-#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, sizeof(table) / sizeof(table[0]), value, prop)
+void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NWindows::NCOM::CPropVariant &prop);
+#define FLAGS64_TO_PROP(pairs, value, prop) Flags64ToProp(pairs, ARRAY_SIZE(pairs), value, prop)
 
 #endif