19.00

CPP/7zip/Archive/7z/7zDecode.cpp

@@ -355,7 +355,9 @@ HRESULT CDecoder::Decode(
 
   unsigned i;
 
+  #if !defined(_7ZIP_ST)
   bool mt_wasUsed = false;
+  #endif
 
   for (i = 0; i < folderInfo.Coders.Size(); i++)
   {

CPP/7zip/Archive/FatHandler.cpp

@@ -733,7 +733,13 @@ HRESULT CDatabase::Open()
   RINOK(OpenProgressFat());
 
   if ((Fat[0] & 0xFF) != Header.MediaType)
-     return S_FALSE;
+  {
+    // that case can mean error in FAT,
+    // but xdf file: (MediaType == 0xF0 && Fat[0] == 0xFF9)
+    // 19.00: so we use non-strict check
+    if ((Fat[0] & 0xFF) < 0xF0)
+      return S_FALSE;
+  }
 
   RINOK(ReadDir(-1, Header.RootCluster, 0));
 

CPP/7zip/Archive/PeHandler.cpp

@@ -41,9 +41,8 @@ static const UInt32 k_Signature32 = 0x00004550;
 
 static HRESULT CalcCheckSum(ISequentialInStream *stream, UInt32 size, UInt32 excludePos, UInt32 &res)
 {
-  const UInt32 kBufSizeMax = (UInt32)1 << 16;
-  UInt32 bufSize = MyMin(kBufSizeMax, size);
-  bufSize += (bufSize & 1);
+  const UInt32 kBufSizeMax = (UInt32)1 << 15;
+  UInt32 bufSize = kBufSizeMax;
   CByteBuffer buffer(bufSize);
   Byte *buf = buffer;
   UInt32 sum = 0;
@@ -58,9 +57,6 @@ static HRESULT CalcCheckSum(ISequentialInStream *stream, UInt32 size, UInt32 exc
     size_t processed = rem;
     RINOK(ReadStream(stream, buf, &processed));
     
-    if ((processed & 1) != 0)
-      buf[processed] = 0;
-
     for (unsigned j = 0; j < 4; j++)
     {
       UInt32 e = excludePos + j;
@@ -72,11 +68,30 @@ static HRESULT CalcCheckSum(ISequentialInStream *stream, UInt32 size, UInt32 exc
       }
     }
 
-    for (size_t i = 0; i < processed; i += 2)
+    const unsigned kStep = (1 << 4);
     {
-      sum += Get16(buf + i);
-      sum = (sum + (sum >> 16)) & 0xFFFF;
+      for (size_t i = processed; (i & (kStep - 1)) != 0; i++)
+        buf[i] = 0;
     }
+    {
+      const Byte *buf2 = buf;
+      const Byte *bufLimit = buf + processed;
+      UInt64 sum2 = 0;
+      for (; buf2 < bufLimit; buf2 += kStep)
+      {
+        UInt64 sum3 = (UInt64)Get32(buf2)
+            + Get32(buf2 + 4)
+            + Get32(buf2 + 8)
+            + Get32(buf2 + 12);
+        sum2 += sum3;
+      }
+      sum2 = (UInt32)(sum2) + (UInt64)(sum2 >> 32);
+      UInt32 sum3 = ((UInt32)sum2 + (UInt32)(sum2 >> 32));
+      sum += (sum3 & 0xFFFF) + (sum3 >> 16);
+      sum = (sum & 0xFFFF) + (sum >> 16);
+      sum = (sum & 0xFFFF) + (sum >> 16);
+    }
+
     pos += (UInt32)processed;
     if (rem != processed)
       break;

CPP/7zip/Archive/Rar/Rar5Handler.cpp

@@ -7,6 +7,7 @@
 
 #include "../../../Common/ComTry.h"
 #include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
 #include "../../../Common/UTFConvert.h"
 
 #include "../../../Windows/PropVariantUtils.h"
@@ -104,37 +105,6 @@ static const char * const g_LinkTypes[] =
 static const char g_ExtraTimeFlags[] = { 'u', 'M', 'C', 'A', 'n' };
 
 
-template <unsigned alignMask>
-struct CAlignedBuffer
-{
-  Byte *_buf;
-  Byte *_bufBase;
-  size_t _size;
-
-  CAlignedBuffer(): _buf(NULL), _bufBase(NULL), _size(0) {}
-  ~CAlignedBuffer() { ::MyFree(_bufBase); }
-public:
-  operator       Byte *()       { return _buf; }
-  operator const Byte *() const { return _buf; }
-
-  void AllocAtLeast(size_t size)
-  {
-    if (_buf && _size >= size)
-      return;
-    ::MyFree(_bufBase);
-    _buf = NULL;
-    _size = 0;
-    _bufBase = (Byte *)::MyAlloc(size + alignMask);
-   
-    if (_bufBase)
-    {
-      _size = size;
-      // _buf = (Byte *)(((uintptr_t)_bufBase + alignMask) & ~(uintptr_t)alignMask);
-         _buf = (Byte *)(((ptrdiff_t)_bufBase + alignMask) & ~(ptrdiff_t)alignMask);
-    }
-  }
-};
-
 static unsigned ReadVarInt(const Byte *p, size_t maxSize, UInt64 *val)
 {
   *val = 0;
@@ -578,7 +548,7 @@ STDMETHODIMP COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *pr
 
 class CInArchive
 {
-  CAlignedBuffer<AES_BLOCK_SIZE - 1> _buf;
+  CAlignedBuffer _buf;
   size_t _bufSize;
   size_t _bufPos;
   ISequentialInStream *_stream;
@@ -586,7 +556,7 @@ class CInArchive
   NCrypto::NRar5::CDecoder *m_CryptoDecoderSpec;
   CMyComPtr<ICompressFilter> m_CryptoDecoder;
 
-
+  CLASS_NO_COPY(CInArchive)
 
   HRESULT ReadStream_Check(void *data, size_t size);
 
@@ -610,6 +580,8 @@ public:
     UInt64 DataSize;
   };
 
+  CInArchive() {}
+
   HRESULT ReadBlockHeader(CHeader &h);
   bool ReadFileHeader(const CHeader &header, CItem &item);
   void AddToSeekValue(UInt64 addValue)

CPP/7zip/Archive/Rar/RarHandler.cpp

@@ -6,6 +6,7 @@
 
 #include "../../../Common/ComTry.h"
 #include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
 #include "../../../Common/UTFConvert.h"
 
 #include "../../../Windows/PropVariantUtils.h"
@@ -136,8 +137,7 @@ class CInArchive
   NHeader::NBlock::CBlock m_BlockHeader;
   NCrypto::NRar3::CDecoder *m_RarAESSpec;
   CMyComPtr<ICompressFilter> m_RarAES;
-  CByteBuffer m_DecryptedData;
-  Byte *m_DecryptedDataAligned;
+  CAlignedBuffer m_DecryptedDataAligned;
   UInt32 m_DecryptedDataSize;
   bool m_CryptoMode;
   UInt32 m_CryptoPos;
@@ -553,11 +553,12 @@ HRESULT CInArchive::GetNextItem(CItem &item, ICryptoGetTextPassword *getTextPass
       m_RarAESSpec->SetPassword((const Byte *)buffer, len * 2);
 
       const UInt32 kDecryptedBufferSize = (1 << 12);
-      if (m_DecryptedData.Size() == 0)
+      if (m_DecryptedDataAligned.Size() == 0)
       {
-        const UInt32 kAlign = 16;
-        m_DecryptedData.Alloc(kDecryptedBufferSize + kAlign);
-        m_DecryptedDataAligned = (Byte *)((ptrdiff_t)((Byte *)m_DecryptedData + kAlign - 1) & ~(ptrdiff_t)(kAlign - 1));
+        // const UInt32 kAlign = 16;
+        m_DecryptedDataAligned.AllocAtLeast(kDecryptedBufferSize);
+        if (!m_DecryptedDataAligned.IsAllocated())
+          return E_OUTOFMEMORY;
       }
       RINOK(m_RarAES->Init());
       size_t decryptedDataSizeT = kDecryptedBufferSize;

CPP/7zip/Archive/UefiHandler.cpp

@@ -791,20 +791,24 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
 void CHandler::AddCommentString(const char *name, UInt32 pos)
 {
   UString s;
-  const Byte *buf = _bufs[0];
   if (pos < _h.HeaderSize)
     return;
-  for (UInt32 i = pos;; i += 2)
+  if (pos >= _h.OffsetToCapsuleBody)
+    return;
+  UInt32 limit = (_h.OffsetToCapsuleBody - pos) & ~(UInt32)1;
+  const Byte *buf = _bufs[0] + pos;
+  for (UInt32 i = 0;;)
   {
-    if (s.Len() > (1 << 16) || i >= _h.OffsetToCapsuleBody)
+    if (s.Len() > (1 << 16) || i >= limit)
       return;
     wchar_t c = Get16(buf + i);
+    i += 2;
     if (c == 0)
     {
-      i += 2;
-      if (i >= _h.OffsetToCapsuleBody)
+      if (i >= limit)
         return;
       c = Get16(buf + i);
+      i += 2;
       if (c == 0)
         break;
       s.Add_LF();

CPP/7zip/Archive/Wim/WimHandlerOut.cpp

@@ -671,7 +671,7 @@ void CHeader::SetDefaultFields(bool useLZX)
     ChunkSize = kChunkSize;
     ChunkSizeBits = kChunkSizeBits;
   }
-  g_RandomGenerator.Generate(Guid, 16);
+  MY_RAND_GEN(Guid, 16);
   PartNumber = 1;
   NumParts = 1;
   NumImages = 1;

CPP/7zip/Bundles/Alone/Alone.dsp

@@ -2496,6 +2496,15 @@ SOURCE=..\..\..\..\C\Delta.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\HuffEnc.c
 
 !IF  "$(CFG)" == "Alone - Win32 Release"

CPP/7zip/Bundles/Alone/makefile

@@ -1,11 +1,4 @@
 PROG = 7za.exe
-MY_CONSOLE = 1
-CFLAGS = $(CFLAGS)
-
-!IFNDEF UNDER_CE
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -D_7ZIP_LARGE_PAGES -DSUPPORT_DEVICE_FILE
-!ENDIF
-
 
 COMMON_OBJS = \
   $O\CommandLineParser.obj \

CPP/7zip/Bundles/Alone7z/Alone.dsp

@@ -1646,6 +1646,15 @@ SOURCE=..\..\..\..\C\Delta.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\IStream.h
 # End Source File
 # Begin Source File

CPP/7zip/Bundles/Alone7z/makefile

@@ -1,10 +1,6 @@
 PROG = 7zr.exe
-MY_CONSOLE = 1
-CFLAGS = $(CFLAGS) -DPROG_VARIANT_R
-
-!IFNDEF UNDER_CE
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -D_7ZIP_LARGE_PAGES -DSUPPORT_DEVICE_FILE
-!ENDIF
+CFLAGS = $(CFLAGS) \
+  -DPROG_VARIANT_R \
 
 COMMON_OBJS = \
   $O\CommandLineParser.obj \

CPP/7zip/Bundles/Fm/FM.dsp

@@ -985,6 +985,15 @@ SOURCE=..\..\..\..\C\CpuArch.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\LzFind.c
 # SUBTRACT CPP /YX /Yc /Yu
 # End Source File

CPP/7zip/Bundles/Fm/makefile

@@ -1,14 +1,4 @@
 PROG = 7zFM.exe
-CFLAGS = $(CFLAGS) \
-  -DLANG \
-  -DNEW_FOLDER_INTERFACE \
-
-!IFDEF UNDER_CE
-LIBS = $(LIBS) ceshell.lib Commctrl.lib
-!ELSE
-LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -DSUPPORT_DEVICE_FILE
-!ENDIF
 
 !include "../Format7zF/Arc.mak"
 

CPP/7zip/Bundles/LzmaCon/makefile

@@ -1,6 +1,5 @@
 PROG = lzma.exe
 MY_CONSOLE = 1
-CFLAGS = $(CFLAGS)
 
 CURRENT_OBJS = \
   $O\LzmaAlone.obj \

CPP/7zip/Bundles/SFXCon/makefile

@@ -6,7 +6,6 @@ CFLAGS = $(CFLAGS) \
   -DEXTRACT_ONLY \
   -DNO_READ_FROM_CODER \
   -D_SFX \
-  -D_CONSOLE \
 
 CURRENT_OBJS = \
   $O\SfxCon.obj \

CPP/7zip/Common/FilterCoder.cpp

@@ -7,6 +7,23 @@
 #include "FilterCoder.h"
 #include "StreamUtils.h"
 
+#ifdef _WIN32
+  #define alignedMidBuffer_Alloc g_MidAlloc
+#else
+  #define alignedMidBuffer_Alloc g_AlignedAlloc
+#endif
+
+CAlignedMidBuffer::~CAlignedMidBuffer()
+{
+  ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
+}
+
+void CAlignedMidBuffer::AllocAligned(size_t size)
+{
+  ISzAlloc_Free(&alignedMidBuffer_Alloc, _buf);
+  _buf = (Byte *)ISzAlloc_Alloc(&alignedMidBuffer_Alloc, size);
+}
+
 /*
   AES filters need 16-bytes alignment for HARDWARE-AES instructions.
   So we call IFilter::Filter(, size), where (size != 16 * N) only for last data block.
@@ -36,7 +53,7 @@ HRESULT CFilterCoder::Alloc()
     size = kMinSize;
   if (!_buf || _bufSize != size)
   {
-    AllocAlignedMask(size, 16 - 1);
+    AllocAligned(size);
     if (!_buf)
       return E_OUTOFMEMORY;
     _bufSize = size;

CPP/7zip/Common/FilterCoder.h

@@ -19,41 +19,11 @@
 
 struct CAlignedMidBuffer
 {
-  #ifdef _WIN32
-
   Byte *_buf;
 
   CAlignedMidBuffer(): _buf(NULL) {}
-  ~CAlignedMidBuffer() { ::MidFree(_buf); }
-  
-  void AllocAlignedMask(size_t size, size_t)
-  {
-    ::MidFree(_buf);
-    _buf = (Byte *)::MidAlloc(size);
-  }
-  
-  #else
-  
-  Byte *_bufBase;
-  Byte *_buf;
-
-  CAlignedMidBuffer(): _bufBase(NULL), _buf(NULL) {}
-  ~CAlignedMidBuffer() { ::MidFree(_bufBase); }
-  
-  void AllocAlignedMask(size_t size, size_t alignMask)
-  {
-    ::MidFree(_bufBase);
-    _buf = NULL;
-    _bufBase = (Byte *)::MidAlloc(size + alignMask);
-    
-    if (_bufBase)
-    {
-      // _buf = (Byte *)(((uintptr_t)_bufBase + alignMask) & ~(uintptr_t)alignMask);
-         _buf = (Byte *)(((ptrdiff_t)_bufBase + alignMask) & ~(ptrdiff_t)alignMask);
-    }
-  }
-  
-  #endif
+  ~CAlignedMidBuffer();
+  void AllocAligned(size_t size);
 };
 
 class CFilterCoder:

CPP/7zip/Crypto/7zAes.cpp

@@ -164,8 +164,8 @@ STDMETHODIMP CEncoder::ResetInitVector()
 {
   for (unsigned i = 0; i < sizeof(_iv); i++)
     _iv[i] = 0;
-  _ivSize = 8;
-  g_RandomGenerator.Generate(_iv, _ivSize);
+  _ivSize = 16;
+  MY_RAND_GEN(_iv, _ivSize);
   return S_OK;
 }
 

CPP/7zip/Crypto/RandGen.cpp

@@ -2,14 +2,44 @@
 
 #include "StdAfx.h"
 
+#include "RandGen.h"
+
+#ifndef USE_STATIC_SYSTEM_RAND
+
 #ifndef _7ZIP_ST
 #include "../../Windows/Synchronization.h"
 #endif
 
-#include "RandGen.h"
 
-#ifndef _WIN32
+#ifdef _WIN32
+
+#ifdef _WIN64
+#define USE_STATIC_RtlGenRandom
+#endif
+
+#ifdef USE_STATIC_RtlGenRandom
+
+#include <ntsecapi.h>
+
+EXTERN_C_BEGIN
+#ifndef RtlGenRandom
+  #define RtlGenRandom SystemFunction036
+  BOOLEAN WINAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);
+#endif
+EXTERN_C_END
+
+#else
+EXTERN_C_BEGIN
+typedef BOOLEAN (WINAPI * Func_RtlGenRandom)(PVOID RandomBuffer, ULONG RandomBufferLength);
+EXTERN_C_END
+#endif
+
+
+#else
 #include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #define USE_POSIX_TIME
 #define USE_POSIX_TIME2
 #endif
@@ -21,11 +51,9 @@
 #endif
 #endif
 
-// This is not very good random number generator.
-// Please use it only for salt.
-// First generated data block depends from timer and processID.
+// The seed and first generated data block depend from processID,
+// theadID, timer and system random generator, if available.
 // Other generated data blocks depend from previous state
-// Maybe it's possible to restore original timer value from generated value.
 
 #define HASH_UPD(x) Sha256_Update(&hash, (const Byte *)&x, sizeof(x));
 
@@ -34,25 +62,102 @@ void CRandomGenerator::Init()
   CSha256 hash;
   Sha256_Init(&hash);
 
+  unsigned numIterations = 1000;
+
+  {
+  #ifndef UNDER_CE
+  const unsigned kNumIterations_Small = 100;
+  const unsigned kBufSize = 32;
+  Byte buf[kBufSize];
+  #endif
+
   #ifdef _WIN32
+
   DWORD w = ::GetCurrentProcessId();
   HASH_UPD(w);
   w = ::GetCurrentThreadId();
   HASH_UPD(w);
+
+  #ifdef UNDER_CE
+  /*
+  if (CeGenRandom(kBufSize, buf))
+  {
+    numIterations = kNumIterations_Small;
+    Sha256_Update(&hash, buf, kBufSize);
+  }
+  */
+  #elif defined(USE_STATIC_RtlGenRandom)
+  if (RtlGenRandom(buf, kBufSize))
+  {
+    numIterations = kNumIterations_Small;
+    Sha256_Update(&hash, buf, kBufSize);
+  }
   #else
+  {
+    HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
+    if (hModule)
+    {
+      // SystemFunction036() is real name of RtlGenRandom() function
+      Func_RtlGenRandom my_RtlGenRandom = (Func_RtlGenRandom)GetProcAddress(hModule, "SystemFunction036");
+      if (my_RtlGenRandom)
+      {
+        if (my_RtlGenRandom(buf, kBufSize))
+        {
+          numIterations = kNumIterations_Small;
+          Sha256_Update(&hash, buf, kBufSize);
+        }
+      }
+      ::FreeLibrary(hModule);
+    }
+  }
+  #endif
+
+  #else
+  
   pid_t pid = getpid();
   HASH_UPD(pid);
   pid = getppid();
   HASH_UPD(pid);
+
+  {
+    int f = open("/dev/urandom", O_RDONLY);
+    unsigned numBytes = kBufSize;
+    if (f >= 0)
+    {
+      do
+      {
+        int n = read(f, buf, numBytes);
+        if (n <= 0)
+          break;
+        Sha256_Update(&hash, buf, n);
+        numBytes -= n;
+      }
+      while (numBytes);
+      close(f);
+      if (numBytes == 0)
+        numIterations = kNumIterations_Small;
+    }
+  }
+  /*
+  {
+    int n = getrandom(buf, kBufSize, 0);
+    if (n > 0)
+    {
+      Sha256_Update(&hash, buf, n);
+      if (n == kBufSize)
+        numIterations = kNumIterations_Small;
+    }
+  }
+  */
+
+  #endif
+  }
+
+  #ifdef _DEBUG
+  numIterations = 2;
   #endif
 
-  for (unsigned i = 0; i <
-    #ifdef _DEBUG
-    2;
-    #else
-    1000;
-    #endif
-    i++)
+  do
   {
     #ifdef _WIN32
     LARGE_INTEGER v;
@@ -85,6 +190,8 @@ void CRandomGenerator::Init()
       Sha256_Update(&hash, _buff, SHA256_DIGEST_SIZE);
     }
   }
+  while (--numIterations);
+
   Sha256_Final(&hash, _buff);
   _needInit = false;
 }
@@ -122,3 +229,5 @@ void CRandomGenerator::Generate(Byte *data, unsigned size)
 }
 
 CRandomGenerator g_RandomGenerator;
+
+#endif

CPP/7zip/Crypto/RandGen.h

@@ -5,6 +5,21 @@
 
 #include "../../../C/Sha256.h"
 
+#ifdef _WIN64
+// #define USE_STATIC_SYSTEM_RAND
+#endif
+
+#ifdef USE_STATIC_SYSTEM_RAND
+
+#ifdef _WIN32
+#include <ntsecapi.h>
+#define MY_RAND_GEN(data, size) RtlGenRandom(data, size)
+#else
+#define MY_RAND_GEN(data, size) getrandom(data, size, 0)
+#endif
+
+#else
+
 class CRandomGenerator
 {
   Byte _buff[SHA256_DIGEST_SIZE];
@@ -18,4 +33,8 @@ public:
 
 extern CRandomGenerator g_RandomGenerator;
 
+#define MY_RAND_GEN(data, size) g_RandomGenerator.Generate(data, size)
+
+#endif
+
 #endif

CPP/7zip/Crypto/WzAes.cpp

@@ -96,7 +96,7 @@ STDMETHODIMP CBaseCoder::Init()
 HRESULT CEncoder::WriteHeader(ISequentialOutStream *outStream)
 {
   unsigned saltSize = _key.GetSaltSize();
-  g_RandomGenerator.Generate(_key.Salt, saltSize);
+  MY_RAND_GEN(_key.Salt, saltSize);
   Init2();
   RINOK(WriteStream(outStream, _key.Salt, saltSize));
   return WriteStream(outStream, _key.PwdVerifComputed, kPwdVerifSize);

CPP/7zip/Crypto/ZipCrypto.cpp

@@ -49,7 +49,7 @@ HRESULT CEncoder::WriteHeader_Check16(ISequentialOutStream *outStream, UInt16 cr
      PKZIP 2.0+ used 1 byte CRC check. It's more secure.
      We also use 1 byte CRC. */
 
-  g_RandomGenerator.Generate(h, kHeaderSize - 1);
+  MY_RAND_GEN(h, kHeaderSize - 1);
   // h[kHeaderSize - 2] = (Byte)(crc);
   h[kHeaderSize - 1] = (Byte)(crc >> 8);
   

CPP/7zip/Crypto/ZipStrong.cpp

@@ -85,13 +85,14 @@ HRESULT CDecoder::ReadHeader(ISequentialInStream *inStream, UInt32 crc, UInt64 u
     return E_NOTIMPL;
   RINOK(ReadStream_FALSE(inStream, temp, 4));
   _remSize = GetUi32(temp);
-  const UInt32 kAlign = 16;
+  // const UInt32 kAlign = 16;
   if (_remSize < 16 || _remSize > (1 << 18))
     return E_NOTIMPL;
-  if (_remSize + kAlign > _buf.Size())
+  if (_remSize > _bufAligned.Size())
   {
-    _buf.Alloc(_remSize + kAlign);
-    _bufAligned = (Byte *)((ptrdiff_t)((Byte *)_buf + kAlign - 1) & ~(ptrdiff_t)(kAlign - 1));
+    _bufAligned.AllocAtLeast(_remSize);
+    if (!(Byte *)_bufAligned)
+      return E_OUTOFMEMORY;
   }
   return ReadStream_FALSE(inStream, _bufAligned, _remSize);
 }

CPP/7zip/Crypto/ZipStrong.h

@@ -3,7 +3,7 @@
 #ifndef __CRYPTO_ZIP_STRONG_H
 #define __CRYPTO_ZIP_STRONG_H
 
-#include "../../Common/MyBuffer.h"
+#include "../../Common/MyBuffer2.h"
 
 #include "../IPassword.h"
 
@@ -35,8 +35,7 @@ class CBaseCoder:
 {
 protected:
   CKeyInfo _key;
-  CByteBuffer _buf;
-  Byte *_bufAligned;
+  CAlignedBuffer _bufAligned;
 public:
   STDMETHOD(Init)();
   STDMETHOD(CryptoSetPassword)(const Byte *data, UInt32 size);

CPP/7zip/UI/Common/ArchiveName.cpp

@@ -99,9 +99,28 @@ UString CreateArchiveName(const UStringVector &paths, const NFind::CFileInfo *fi
     name = Get_Correct_FsFile_Name(fs2us(CreateArchiveName2(us2fs(paths.Front()), fromPrev, keepName)));
   }
 
+  UStringVector names;
+
+  {
+    FOR_VECTOR (i, paths)
+    {
+      NFind::CFileInfo fi2;
+      const NFind::CFileInfo *fp;
+      if (fi && paths.Size() == 1)
+        fp = fi;
+      else
+      {
+        if (!fi2.Find(us2fs(paths[i])))
+          continue;
+        fp = &fi2;
+      }
+      names.Add(fs2us(fp->Name));
+    }
+  }
+
   UString postfix;
   UInt32 index = 1;
-  
+
   for (;;)
   {
     // we don't want cases when we include archive to itself.
@@ -113,22 +132,10 @@ UString CreateArchiveName(const UStringVector &paths, const NFind::CFileInfo *fi
     const UString name2_wim = name2 + L".wim";
     
     unsigned i = 0;
-    
-    for (i = 0; i < paths.Size(); i++)
-    {
-      const UString &fn = paths[i];
-      NFind::CFileInfo fi2;
 
-      const NFind::CFileInfo *fp;
-      if (fi && paths.Size() == 1)
-        fp = fi;
-      else
-      {
-        if (!fi2.Find(us2fs(fn)))
-          continue;
-        fp = &fi2;
-      }
-      const UString fname = fs2us(fp->Name);
+    for (i = 0; i < names.Size(); i++)
+    {
+      const UString &fname = names[i];
       if (   0 == CompareFileNames(fname, name2_zip)
           || 0 == CompareFileNames(fname, name2_7z)
           || 0 == CompareFileNames(fname, name2_tar)
@@ -136,7 +143,7 @@ UString CreateArchiveName(const UStringVector &paths, const NFind::CFileInfo *fi
         break;
     }
     
-    if (i == paths.Size())
+    if (i == names.Size())
       break;
     index++;
     postfix = "_";

CPP/7zip/UI/Common/ArchiveOpenCallback.cpp

@@ -102,7 +102,14 @@ STDMETHODIMP COpenCallbackImp::GetStream(const wchar_t *name, IInStream **inStre
   // if (!allowAbsVolPaths)
   if (!IsSafePath(name2))
     return S_FALSE;
-  
+
+  // #ifdef _WIN32
+  // we don't want to support wildcards in names here here
+  if (name2.Find(L'?') >= 0 ||
+      name2.Find(L'*') >= 0)
+    return S_FALSE;
+  // #endif
+
   #endif
 
 

CPP/7zip/UI/Common/Bench.cpp

@@ -29,7 +29,6 @@
 #endif
 
 #include "../../../../C/7zCrc.h"
-#include "../../../../C/Alloc.h"
 #include "../../../../C/CpuArch.h"
 
 #ifndef _7ZIP_ST
@@ -47,6 +46,7 @@
 
 
 #include "../../../Common/IntToString.h"
+#include "../../../Common/MyBuffer2.h"
 #include "../../../Common/StringConvert.h"
 #include "../../../Common/StringToInt.h"
 
@@ -94,80 +94,33 @@ static const UInt32 kAdditionalSize = (1 << 16);
 static const UInt32 kCompressedAdditionalSize = (1 << 10);
 static const UInt32 kMaxLzmaPropSize = 5;
 
+
+
+#define ALLOC_WITH_HRESULT(_buffer_, _size_) \
+  (_buffer_)->Alloc(_size_); \
+  if (!(_buffer_)->IsAllocated()) return E_OUTOFMEMORY;
+
+
 class CBaseRandomGenerator
 {
   UInt32 A1;
   UInt32 A2;
+  UInt32 Salt;
 public:
-  CBaseRandomGenerator() { Init(); }
+  CBaseRandomGenerator(UInt32 salt = 0): Salt(salt) { Init(); }
   void Init() { A1 = 362436069; A2 = 521288629;}
   UInt32 GetRnd()
   {
-    return
+    return Salt ^
+    (
       ((A1 = 36969 * (A1 & 0xffff) + (A1 >> 16)) << 16) +
-      ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) );
+      ((A2 = 18000 * (A2 & 0xffff) + (A2 >> 16)) )
+    );
   }
 };
 
 
-static const unsigned kBufferAlignment = 1 << 4;
-
-struct CBenchBuffer
-{
-  size_t BufferSize;
-
-  #ifdef _WIN32
-
-  Byte *Buffer;
-
-  CBenchBuffer(): BufferSize(0), Buffer(NULL) {}
-  ~CBenchBuffer() { ::MidFree(Buffer); }
-  
-  void AllocAlignedMask(size_t size, size_t)
-  {
-    ::MidFree(Buffer);
-    BufferSize = 0;
-    Buffer = (Byte *)::MidAlloc(size);
-    if (Buffer)
-      BufferSize = size;
-  }
-  
-  #else
-  
-  Byte *Buffer;
-  Byte *_bufBase;
-
-  CBenchBuffer(): BufferSize(0), Buffer(NULL), _bufBase(NULL){}
-  ~CBenchBuffer() { ::MidFree(_bufBase); }
-  
-  void AllocAlignedMask(size_t size, size_t alignMask)
-  {
-    ::MidFree(_bufBase);
-    Buffer = NULL;
-    BufferSize = 0;
-    _bufBase = (Byte *)::MidAlloc(size + alignMask);
-    
-    if (_bufBase)
-    {
-      // Buffer = (Byte *)(((uintptr_t)_bufBase + alignMask) & ~(uintptr_t)alignMask);
-         Buffer = (Byte *)(((ptrdiff_t)_bufBase + alignMask) & ~(ptrdiff_t)alignMask);
-      BufferSize = size;
-    }
-  }
-
-  #endif
-
-  bool Alloc(size_t size)
-  {
-    if (Buffer && BufferSize == size)
-      return true;
-    AllocAlignedMask(size, kBufferAlignment - 1);
-    return (Buffer != NULL || size == 0);
-  }
-};
-
-
-class CBenchRandomGenerator: public CBenchBuffer
+class CBenchRandomGenerator: public CAlignedBuffer
 {
   static UInt32 GetVal(UInt32 &res, unsigned numBits)
   {
@@ -184,23 +137,22 @@ class CBenchRandomGenerator: public CBenchBuffer
 
 public:
   
-  void GenerateSimpleRandom(CBaseRandomGenerator *_RG_)
+  void GenerateSimpleRandom(UInt32 salt)
   {
-    CBaseRandomGenerator rg = *_RG_;
-    const size_t bufSize = BufferSize;
-    Byte *buf = Buffer;
+    CBaseRandomGenerator rg(salt);
+    const size_t bufSize = Size();
+    Byte *buf = (Byte *)*this;
     for (size_t i = 0; i < bufSize; i++)
       buf[i] = (Byte)rg.GetRnd();
-    *_RG_ = rg;
   }
 
-  void GenerateLz(unsigned dictBits, CBaseRandomGenerator *_RG_)
+  void GenerateLz(unsigned dictBits, UInt32 salt)
   {
-    CBaseRandomGenerator rg = *_RG_;
+    CBaseRandomGenerator rg(salt);
     UInt32 pos = 0;
     UInt32 rep0 = 1;
-    const size_t bufSize = BufferSize;
-    Byte *buf = Buffer;
+    const size_t bufSize = Size();
+    Byte *buf = (Byte *)*this;
     unsigned posBits = 1;
     
     while (pos < bufSize)
@@ -255,8 +207,6 @@ public:
           *dest++ = *src++;
       }
     }
-
-    *_RG_ = rg;
   }
 };
 
@@ -297,7 +247,7 @@ STDMETHODIMP CBenchmarkInStream::Read(void *data, UInt32 size, UInt32 *processed
   
 class CBenchmarkOutStream:
   public ISequentialOutStream,
-  public CBenchBuffer,
+  public CAlignedBuffer,
   public CMyUnknownImp
 {
   // bool _overflow;
@@ -325,13 +275,13 @@ public:
 
 STDMETHODIMP CBenchmarkOutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  size_t curSize = BufferSize - Pos;
+  size_t curSize = Size() - Pos;
   if (curSize > size)
     curSize = size;
   if (curSize != 0)
   {
     if (RealCopy)
-      memcpy(Buffer + Pos, data, curSize);
+      memcpy(((Byte *)*this) + Pos, data, curSize);
     if (CalcCrc)
       Crc = CrcUpdate(Crc, data, curSize);
     Pos += curSize;
@@ -686,20 +636,39 @@ UInt64 GetDecompressRating(UInt64 elapsedTime, UInt64 freq, UInt64 outSize, UInt
   return props.GetDecompressRating(elapsedTime, freq, outSize, inSize, numIterations);
 }
 
+
+
+
+#ifndef _7ZIP_ST
+struct CBenchSyncCommon
+{
+  bool ExitMode;
+  NSynchronization::CManualResetEvent StartEvent;
+
+  CBenchSyncCommon(): ExitMode(false) {}
+};
+#endif
+
+
 struct CEncoderInfo;
 
 struct CEncoderInfo
 {
   #ifndef _7ZIP_ST
   NWindows::CThread thread[2];
+  NSynchronization::CManualResetEvent ReadyEvent;
   UInt32 NumDecoderSubThreads;
+  CBenchSyncCommon *Common;
   #endif
+
   CMyComPtr<ICompressCoder> _encoder;
   CMyComPtr<ICompressFilter> _encoderFilter;
   CBenchProgressInfo *progressInfoSpec[2];
   CMyComPtr<ICompressProgressInfo> progressInfo[2];
   UInt64 NumIterations;
 
+  UInt32 Salt;
+
   #ifdef USE_ALLOCA
   size_t AllocaSize;
   #endif
@@ -738,22 +707,25 @@ struct CEncoderInfo
   const Byte *fileData;
   CBenchRandomGenerator rg;
 
-  CBenchBuffer rgCopy; // it must be 16-byte aligned !!!
+  CAlignedBuffer rgCopy; // it must be 16-byte aligned !!!
   CBenchmarkOutStream *propStreamSpec;
   CMyComPtr<ISequentialOutStream> propStream;
 
-  // for decode
+  unsigned generateDictBits;
   COneMethodInfo _method;
+  
+  // for decode
   size_t _uncompressedDataSize;
 
-  HRESULT Init(
-      const COneMethodInfo &method,
-      unsigned generateDictBits,
-      CBaseRandomGenerator *rg);
+  HRESULT Generate();
   HRESULT Encode();
   HRESULT Decode(UInt32 decoderIndex);
 
   CEncoderInfo():
+    #ifndef _7ZIP_ST
+    Common(NULL),
+    #endif
+    Salt(0),
     fileData(NULL),
     CheckCrc_Enc(true),
     CheckCrc_Dec(true),
@@ -772,14 +744,15 @@ struct CEncoderInfo
       #endif
 
       res = encoder->Encode();
-      encoder->Results[0] = res;
     }
     catch(...)
     {
       res = E_FAIL;
     }
+    encoder->Results[0] = res;
     if (res != S_OK)
       encoder->progressInfoSpec[0]->Status->SetResult(res);
+    encoder->ReadyEvent.Set();
     return 0;
   }
   
@@ -798,7 +771,12 @@ struct CEncoderInfo
 
   HRESULT CreateEncoderThread()
   {
-    return thread[0].Create(EncodeThreadFunction, this);
+    WRes res = 0;
+    if (!ReadyEvent.IsCreated())
+      res = ReadyEvent.Create();
+    if (res == 0)
+      res = thread[0].Create(EncodeThreadFunction, this);
+    return HRESULT_FROM_WIN32(res);
   }
 
   HRESULT CreateDecoderThread(unsigned index, bool callbackMode
@@ -823,11 +801,10 @@ struct CEncoderInfo
 };
 
 
-HRESULT CEncoderInfo::Init(
-    const COneMethodInfo &method,
-    unsigned generateDictBits,
-    CBaseRandomGenerator *rgLoc)
+HRESULT CEncoderInfo::Generate()
 {
+  const COneMethodInfo &method = _method;
+
   // we need extra space, if input data is already compressed
   const size_t kCompressedBufferSize =
       kCompressedAdditionalSize +
@@ -841,40 +818,39 @@ HRESULT CEncoderInfo::Init(
   
   if (!fileData)
   {
-    if (!rg.Alloc(kBufferSize))
-      return E_OUTOFMEMORY;
+    ALLOC_WITH_HRESULT(&rg, kBufferSize);
     
     // DWORD ttt = GetTickCount();
     if (generateDictBits == 0)
-      rg.GenerateSimpleRandom(rgLoc);
+      rg.GenerateSimpleRandom(Salt);
     else
-      rg.GenerateLz(generateDictBits, rgLoc);
+      rg.GenerateLz(generateDictBits, Salt);
     // printf("\n%d\n            ", GetTickCount() - ttt);
 
-    crc = CrcCalc(rg.Buffer, rg.BufferSize);
-    uncompressedDataPtr = rg.Buffer;
+    crc = CrcCalc((const Byte *)rg, rg.Size());
+    uncompressedDataPtr = (const Byte *)rg;
   }
   
   if (_encoderFilter)
   {
-    if (!rgCopy.Alloc(kBufferSize))
-      return E_OUTOFMEMORY;
+    ALLOC_WITH_HRESULT(&rgCopy, kBufferSize);
   }
 
 
-  outStreamSpec = new CBenchmarkOutStream;
-  outStream = outStreamSpec;
-  if (!outStreamSpec->Alloc(kCompressedBufferSize))
-    return E_OUTOFMEMORY;
+  if (!outStream)
+  {
+    outStreamSpec = new CBenchmarkOutStream;
+    outStream = outStreamSpec;
+  }
+
+  ALLOC_WITH_HRESULT(outStreamSpec, kCompressedBufferSize)
 
-  propStreamSpec = 0;
   if (!propStream)
   {
     propStreamSpec = new CBenchmarkOutStream;
     propStream = propStreamSpec;
   }
-  if (!propStreamSpec->Alloc(kMaxLzmaPropSize))
-    return E_OUTOFMEMORY;
+  ALLOC_WITH_HRESULT(propStreamSpec, kMaxLzmaPropSize);
   propStreamSpec->Init(true, false);
   
  
@@ -961,6 +937,28 @@ static void My_FilterBench(ICompressFilter *filter, Byte *data, size_t size)
 
 HRESULT CEncoderInfo::Encode()
 {
+  RINOK(Generate());
+
+  #ifndef _7ZIP_ST
+  if (Common)
+  {
+    Results[0] = S_OK;
+    WRes wres = ReadyEvent.Set();
+    if (wres == 0)
+      wres = Common->StartEvent.Lock();
+    if (wres != 0)
+      return HRESULT_FROM_WIN32(wres);
+    if (Common->ExitMode)
+      return S_OK;
+  }
+  else
+  #endif
+  {
+    CBenchProgressInfo *bpi = progressInfoSpec[0];
+    bpi->SetStartTime();
+  }
+
+
   CBenchInfo &bi = progressInfoSpec[0]->BenchInfo;
   bi.UnpackSize = 0;
   bi.PackSize = 0;
@@ -997,10 +995,10 @@ HRESULT CEncoderInfo::Encode()
     
     if (_encoderFilter)
     {
-      memcpy(rgCopy.Buffer, uncompressedDataPtr, kBufferSize);
+      memcpy((Byte *)rgCopy, uncompressedDataPtr, kBufferSize);
       _encoderFilter->Init();
-      My_FilterBench(_encoderFilter, rgCopy.Buffer, kBufferSize);
-      RINOK(WriteStream(outStream, rgCopy.Buffer, kBufferSize));
+      My_FilterBench(_encoderFilter, (Byte *)rgCopy, kBufferSize);
+      RINOK(WriteStream(outStream, (const Byte *)rgCopy, kBufferSize));
     }
     else
     {
@@ -1078,7 +1076,7 @@ HRESULT CEncoderInfo::Decode(UInt32 decoderIndex)
   
   if (setDecProps)
   {
-    RINOK(setDecProps->SetDecoderProperties2(propStreamSpec->Buffer, (UInt32)propStreamSpec->Pos));
+    RINOK(setDecProps->SetDecoderProperties2((const Byte *)*propStreamSpec, (UInt32)propStreamSpec->Pos));
   }
 
   {
@@ -1106,7 +1104,7 @@ HRESULT CEncoderInfo::Decode(UInt32 decoderIndex)
       prev = pi->BenchInfo.UnpackSize;
     }
 
-    inStreamSpec->Init(outStreamSpec->Buffer, compressedSize);
+    inStreamSpec->Init((const Byte *)*outStreamSpec, compressedSize);
     crcOutStreamSpec->Init();
     
     UInt64 outSize = kBufferSize;
@@ -1114,12 +1112,12 @@ HRESULT CEncoderInfo::Decode(UInt32 decoderIndex)
     
     if (_decoderFilter)
     {
-      if (compressedSize > rgCopy.BufferSize)
+      if (compressedSize > rgCopy.Size())
         return E_FAIL;
-      memcpy(rgCopy.Buffer, outStreamSpec->Buffer, compressedSize);
+      memcpy((Byte *)rgCopy, (const Byte *)*outStreamSpec, compressedSize);
       _decoderFilter->Init();
-      My_FilterBench(_decoderFilter, rgCopy.Buffer, compressedSize);
-      RINOK(WriteStream(crcOutStream, rgCopy.Buffer, compressedSize));
+      My_FilterBench(_decoderFilter, (Byte *)rgCopy, compressedSize);
+      RINOK(WriteStream(crcOutStream, (const Byte *)rgCopy, compressedSize));
     }
     else
     {
@@ -1157,6 +1155,57 @@ static UInt64 GetNumIterations(UInt64 numCommands, UInt64 complexInCommands)
 }
 
 
+
+#ifndef _7ZIP_ST
+
+// ---------- CBenchThreadsFlusher ----------
+
+struct CBenchThreadsFlusher
+{
+  CBenchEncoders *EncodersSpec;
+  CBenchSyncCommon Common;
+  unsigned NumThreads;
+  bool NeedClose;
+
+  CBenchThreadsFlusher(): NumThreads(0), NeedClose(false) {}
+  
+  ~CBenchThreadsFlusher()
+  {
+    StartAndWait(true);
+  }
+
+  WRes StartAndWait(bool exitMode = false);
+};
+
+
+WRes CBenchThreadsFlusher::StartAndWait(bool exitMode)
+{
+  if (!NeedClose)
+    return 0;
+
+  Common.ExitMode = exitMode;
+  WRes res = Common.StartEvent.Set();
+
+  for (unsigned i = 0; i < NumThreads; i++)
+  {
+    NWindows::CThread &t = EncodersSpec->encoders[i].thread[0];
+    if (t.IsCreated())
+    {
+      WRes res2 = t.Wait();
+      if (res2 == 0)
+        res2 = t.Close();
+      if (res == S_OK)
+        res = res2;
+    }
+  }
+  NeedClose = false;
+  return res;
+}
+
+#endif
+
+
+
 static HRESULT MethodBench(
     DECL_EXTERNAL_CODECS_LOC_VARS
     UInt64 complexInCommands,
@@ -1208,6 +1257,8 @@ static HRESULT MethodBench(
         numSubDecoderThreads = 2;
       }
     }
+
+  bool mtEncMode = (numEncoderThreads > 1);
   #endif
 
   CBenchEncoders encodersSpec(numEncoderThreads);
@@ -1247,9 +1298,6 @@ static HRESULT MethodBench(
     }
   }
 
-  CBaseRandomGenerator rg;
-  rg.Init();
-
   UInt32 crc = 0;
   if (fileData)
     crc = CrcCalc(fileData, uncompressedDataSize);
@@ -1258,22 +1306,38 @@ static HRESULT MethodBench(
   {
     CEncoderInfo &encoder = encoders[i];
     encoder._method = method;
+    encoder.generateDictBits = generateDictBits;
     encoder._uncompressedDataSize = uncompressedDataSize;
     encoder.kBufferSize = uncompressedDataSize;
     encoder.fileData = fileData;
     encoder.crc = crc;
-
-    RINOK(encoders[i].Init(method, generateDictBits, &rg));
   }
 
   CBenchProgressStatus status;
   status.Res = S_OK;
   status.EncodeMode = true;
 
+  #ifndef _7ZIP_ST
+  CBenchThreadsFlusher encoderFlusher;
+  if (mtEncMode)
+  {
+    WRes wres = encoderFlusher.Common.StartEvent.Create();
+    if (wres != 0)
+      return HRESULT_FROM_WIN32(wres);
+    encoderFlusher.NumThreads = numEncoderThreads;
+    encoderFlusher.EncodersSpec = &encodersSpec;
+    encoderFlusher.NeedClose = true;
+  }
+  #endif
+
   for (i = 0; i < numEncoderThreads; i++)
   {
     CEncoderInfo &encoder = encoders[i];
     encoder.NumIterations = GetNumIterations(benchProps->GeComprCommands(uncompressedDataSize), complexInCommands);
+    encoder.Salt = g_CrcTable[i & 0xFF];
+    encoder.Salt ^= (g_CrcTable[(i >> 8) & 0xFF] << 3);
+    // (g_CrcTable[0] == 0), and (encoder.Salt == 0) for first thread
+    // printf(" %8x", encoder.Salt);
 
     for (int j = 0; j < 2; j++)
     {
@@ -1288,30 +1352,50 @@ static HRESULT MethodBench(
       CBenchProgressInfo *bpi = encoder.progressInfoSpec[0];
       bpi->Callback = callback;
       bpi->BenchInfo.NumIterations = numEncoderThreads;
-      bpi->SetStartTime();
     }
 
     #ifndef _7ZIP_ST
-    if (numEncoderThreads > 1)
+    if (mtEncMode)
     {
       #ifdef USE_ALLOCA
       encoder.AllocaSize = (i * 16 * 21) & 0x7FF;
       #endif
 
+      encoder.Common = &encoderFlusher.Common;
       RINOK(encoder.CreateEncoderThread())
     }
-    else
     #endif
-    {
-      RINOK(encoder.Encode());
-    }
   }
-  
+
+  if (printCallback)
+  {
+    RINOK(printCallback->CheckBreak());
+  }
+
   #ifndef _7ZIP_ST
-  if (numEncoderThreads > 1)
+  if (mtEncMode)
+  {
     for (i = 0; i < numEncoderThreads; i++)
-      encoders[i].thread[0].Wait();
+    {
+      CEncoderInfo &encoder = encoders[i];
+      WRes wres = encoder.ReadyEvent.Lock();
+      if (wres != 0)
+        return HRESULT_FROM_WIN32(wres);
+      RINOK(encoder.Results[0]);
+    }
+
+    CBenchProgressInfo *bpi = encoders[0].progressInfoSpec[0];
+    bpi->SetStartTime();
+
+    WRes wres = encoderFlusher.StartAndWait();
+    if (status.Res == 0 && wres != 0)
+      return HRESULT_FROM_WIN32(wres);
+  }
+  else
   #endif
+  {
+    RINOK(encoders[0].Encode());
+  }
 
   RINOK(status.Res);
 
@@ -1327,11 +1411,16 @@ static HRESULT MethodBench(
     CEncoderInfo &encoder = encoders[i];
     info.UnpackSize += encoder.kBufferSize;
     info.PackSize += encoder.compressedSize;
+    // printf("\n%7d\n", encoder.compressedSize);
   }
   
   RINOK(callback->SetEncodeResult(info, true));
 
 
+
+
+  // ---------- Decode ----------
+
   status.Res = S_OK;
   status.EncodeMode = false;
 
@@ -1618,21 +1707,21 @@ struct CCrcThreads
 
 #endif
 
-static UInt32 CrcCalc1(const Byte *buf, UInt32 size)
+static UInt32 CrcCalc1(const Byte *buf, size_t size)
 {
   UInt32 crc = CRC_INIT_VAL;;
-  for (UInt32 i = 0; i < size; i++)
+  for (size_t i = 0; i < size; i++)
     crc = CRC_UPDATE_BYTE(crc, buf[i]);
   return CRC_GET_DIGEST(crc);
 }
 
-static void RandGen(Byte *buf, UInt32 size, CBaseRandomGenerator &RG)
+static void RandGen(Byte *buf, size_t size, CBaseRandomGenerator &RG)
 {
-  for (UInt32 i = 0; i < size; i++)
+  for (size_t i = 0; i < size; i++)
     buf[i] = (Byte)RG.GetRnd();
 }
 
-static UInt32 RandGenCrc(Byte *buf, UInt32 size, CBaseRandomGenerator &RG)
+static UInt32 RandGenCrc(Byte *buf, size_t size, CBaseRandomGenerator &RG)
 {
   RandGen(buf, size, RG);
   return CrcCalc1(buf, size);
@@ -1640,14 +1729,15 @@ static UInt32 RandGenCrc(Byte *buf, UInt32 size, CBaseRandomGenerator &RG)
 
 bool CrcInternalTest()
 {
-  CBenchBuffer buffer;
-  const UInt32 kBufferSize0 = (1 << 8);
-  const UInt32 kBufferSize1 = (1 << 10);
-  const UInt32 kCheckSize = (1 << 5);
-  if (!buffer.Alloc(kBufferSize0 + kBufferSize1))
+  CAlignedBuffer buffer;
+  const size_t kBufferSize0 = (1 << 8);
+  const size_t kBufferSize1 = (1 << 10);
+  const unsigned kCheckSize = (1 << 5);
+  buffer.Alloc(kBufferSize0 + kBufferSize1);
+  if (!buffer.IsAllocated())
     return false;
-  Byte *buf = buffer.Buffer;
-  UInt32 i;
+  Byte *buf = (Byte *)buffer;
+  size_t i;
   for (i = 0; i < kBufferSize0; i++)
     buf[i] = (Byte)i;
   UInt32 crc1 = CrcCalc1(buf, kBufferSize0);
@@ -1656,7 +1746,7 @@ bool CrcInternalTest()
   CBaseRandomGenerator RG;
   RandGen(buf + kBufferSize0, kBufferSize1, RG);
   for (i = 0; i < kBufferSize0 + kBufferSize1 - kCheckSize; i++)
-    for (UInt32 j = 0; j < kCheckSize; j++)
+    for (unsigned j = 0; j < kCheckSize; j++)
       if (CrcCalc1(buf + i, j) != CrcCalc(buf + i, j))
         return false;
   return true;
@@ -1920,6 +2010,10 @@ void Add_LargePages_String(AString &s)
   {
     s += " (LP-";
     PrintSize(s, g_LargePageSize);
+    #ifdef MY_CPU_X86_OR_AMD64
+    if (CPU_IsSupported_PageGB())
+      s += "-1G";
+    #endif
     if (!g_LargePagesMode)
       s += "-NA";
     s += ")";
@@ -2238,14 +2332,13 @@ static HRESULT CrcBench(
       methodName, hashID))
     return E_NOTIMPL;
 
-  CBenchBuffer buffer;
+  CAlignedBuffer buffer;
   size_t totalSize = (size_t)bufferSize * numThreads;
   if (totalSize / numThreads != bufferSize)
     return E_OUTOFMEMORY;
-  if (!buffer.Alloc(totalSize))
-    return E_OUTOFMEMORY;
+  ALLOC_WITH_HRESULT(&buffer, totalSize)
 
-  Byte *buf = buffer.Buffer;
+  Byte *buf = (Byte *)buffer;
   CBaseRandomGenerator RG;
   UInt32 bsize = (bufferSize == 0 ? 1 : bufferSize);
   UInt64 numIterations = complexInCommands * 256 / complexity / bsize;
@@ -2793,7 +2886,7 @@ HRESULT Bench(
     bool multiDict)
 {
   if (!CrcInternalTest())
-    return S_FALSE;
+    return E_FAIL;
 
   UInt32 numCPUs = 1;
   UInt64 ramSize = (UInt64)(sizeof(size_t)) << 29;
@@ -2822,7 +2915,7 @@ HRESULT Bench(
 
   COneMethodInfo method;
 
-  CBenchBuffer fileDataBuffer;
+  CAlignedBuffer fileDataBuffer;
 
   {
   unsigned i;
@@ -2847,10 +2940,9 @@ HRESULT Bench(
         return E_FAIL;
       if (len >= ((UInt32)1 << 31) || len == 0)
         return E_INVALIDARG;
-      if (!fileDataBuffer.Alloc((size_t)len))
-        return E_OUTOFMEMORY;
+      ALLOC_WITH_HRESULT(&fileDataBuffer, (size_t)len);
       UInt32 processedSize;
-      file.Read(fileDataBuffer.Buffer, (UInt32)len, processedSize);
+      file.Read((Byte *)fileDataBuffer, (UInt32)len, processedSize);
       if (processedSize != len)
         return E_FAIL;
       if (printCallback)
@@ -3066,7 +3158,7 @@ HRESULT Bench(
         complexInCommands,
         true, numThreadsSpecified,
         method,
-        uncompressedDataSize, fileDataBuffer.Buffer,
+        uncompressedDataSize, (const Byte *)fileDataBuffer,
         kOldLzmaDictBits, printCallback, benchCallback, &benchProps);
   }
 
@@ -3378,9 +3470,9 @@ HRESULT Bench(
       {
         res = TotalBench(EXTERNAL_CODECS_LOC_VARS
             complexInCommands, numThreads,
-            dictIsDefined || fileDataBuffer.Buffer, // forceUnpackSize
-            fileDataBuffer.Buffer ? fileDataBuffer.BufferSize : dict,
-            fileDataBuffer.Buffer,
+            dictIsDefined || fileDataBuffer.IsAllocated(), // forceUnpackSize
+            fileDataBuffer.IsAllocated() ? fileDataBuffer.Size() : dict,
+            (const Byte *)fileDataBuffer,
             printCallback, &callback);
         RINOK(res);
       }
@@ -3470,9 +3562,9 @@ HRESULT Bench(
       }
 
       size_t uncompressedDataSize;
-      if (fileDataBuffer.Buffer)
+      if (fileDataBuffer.IsAllocated())
       {
-        uncompressedDataSize = fileDataBuffer.BufferSize;
+        uncompressedDataSize = fileDataBuffer.Size();
       }
       else
       {
@@ -3486,7 +3578,7 @@ HRESULT Bench(
           complexInCommands,
           true, numThreads,
           method2,
-          uncompressedDataSize, fileDataBuffer.Buffer,
+          uncompressedDataSize, (const Byte *)fileDataBuffer,
           kOldLzmaDictBits, printCallback, &callback, &callback.BenchProps);
       f.NewLine();
       RINOK(res);

CPP/7zip/UI/Console/Console.dsp

@@ -417,6 +417,10 @@ SOURCE=..\..\..\Common\MyBuffer.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\Common\MyBuffer2.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\Common\MyCom.h
 # End Source File
 # Begin Source File
@@ -843,6 +847,15 @@ SOURCE=..\..\..\..\C\CpuArch.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\Sort.c
 # SUBTRACT CPP /YX /Yc /Yu
 # End Source File

CPP/7zip/UI/Console/Console.mak

@@ -1,3 +1,9 @@
+MY_CONSOLE = 1
+
+!IFNDEF UNDER_CE
+CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -D_7ZIP_LARGE_PAGES -DSUPPORT_DEVICE_FILE
+!ENDIF
+
 CONSOLE_OBJS = \
   $O\BenchCon.obj \
   $O\ConsoleClose.obj \
@@ -33,4 +39,5 @@ UI_COMMON_OBJS = \
   $O\UpdatePair.obj \
   $O\UpdateProduce.obj \
 
-#
+C_OBJS = $(C_OBJS) \
+  $O\DllSecur.obj \

CPP/7zip/UI/Console/Main.cpp

@@ -87,7 +87,7 @@ static const char * const kHelpString =
     "a"
 #endif
 #endif
-    " <command> [<switches>...] <archive_name> [<file_names>...]\n"
+    " <command> [<switches>...] <archive_name> [<file_names>...] [@listfile]\n"
     "\n"
     "<Commands>\n"
     "  a : Add files to archive\n"
@@ -103,8 +103,7 @@ static const char * const kHelpString =
     "  x : eXtract files with full paths\n"
     "\n"
     "<Switches>\n"
-    "  -- : Stop switches parsing\n"
-    "  @listfile : set path to listfile that contains file names\n"
+    "  -- : Stop switches and @listfile parsing\n"
     "  -ai[r[-|0]]{@listfile|!wildcard} : Include archives\n"
     "  -ax[r[-|0]]{@listfile|!wildcard} : eXclude archives\n"
     "  -ao{a|s|t|u} : set Overwrite mode\n"

CPP/7zip/UI/Console/MainAr.cpp

@@ -2,6 +2,10 @@
 
 #include "StdAfx.h"
 
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+
 #include "../../../Common/MyException.h"
 #include "../../../Common/StdOutStream.h"
 
@@ -63,6 +67,10 @@ int MY_CDECL main
   
   try
   {
+    #ifdef _WIN32
+    My_SetDefaultDllDirectories();
+    #endif
+
     res = Main2(
     #ifndef _WIN32
     numArgs, args

CPP/7zip/UI/Console/makefile

@@ -1,12 +1,7 @@
 PROG = 7z.exe
-MY_CONSOLE = 1
 CFLAGS = $(CFLAGS)  \
   -DEXTERNAL_CODECS \
 
-!IFNDEF UNDER_CE
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -D_7ZIP_LARGE_PAGES -DSUPPORT_DEVICE_FILE
-!ENDIF
-
 COMMON_OBJS = \
   $O\CommandLineParser.obj \
   $O\CRC.obj \
@@ -57,7 +52,7 @@ AR_COMMON_OBJS = \
 COMPRESS_OBJS = \
   $O\CopyCoder.obj \
 
-C_OBJS = \
+C_OBJS = $(C_OBJS) \
   $O\Alloc.obj \
   $O\CpuArch.obj \
   $O\Sort.obj \

CPP/7zip/UI/Explorer/ContextMenu.cpp

@@ -120,7 +120,11 @@ HRESULT CZipContextMenu::InitContextMenu(const wchar_t * /* folder */, const wch
   _isMenuForFM = true;
   _fileNames.Clear();
   for (UInt32 i = 0; i < numFiles; i++)
+  {
+    // MessageBoxW(0, names[i], NULL, 0);
+    // OutputDebugStringW(names[i]);
     _fileNames.Add(names[i]);
+  }
   _dropMode = false;
   return S_OK;
 }
@@ -423,6 +427,13 @@ STDMETHODIMP CZipContextMenu::QueryContextMenu(HMENU hMenu, UINT indexMenu,
 {
   // OutputDebugStringA("QueryContextMenu");
 
+  /*
+  for (UInt32 i = 0; i < _fileNames.Size(); i++)
+  {
+    OutputDebugStringW(_fileNames[i]);
+  }
+  */
+
   LoadLangOneTime();
   if (_fileNames.Size() == 0)
     return E_FAIL;

CPP/7zip/UI/Explorer/Explorer.dsp

@@ -286,6 +286,15 @@ SOURCE=..\FileManager\RegistryUtils.h
 # PROP Default_Filter ""
 # Begin Source File
 
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\CpuArch.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\Threads.c
 # SUBTRACT CPP /YX /Yc /Yu
 # End Source File

CPP/7zip/UI/Explorer/makefile

@@ -68,6 +68,7 @@ FM_OBJS = \
   $O\RegistryUtils.obj \
 
 C_OBJS = \
+  $O\CpuArch.obj \
   $O\Threads.obj \
 
 !include "../../7zip.mak"

CPP/7zip/UI/FileManager/FM.cpp

@@ -7,6 +7,9 @@
 #include <shlwapi.h>
 
 #include "../../../../C/Alloc.h"
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
 
 #include "../../../Common/StringConvert.h"
 #include "../../../Common/StringToInt.h"
@@ -660,6 +663,9 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
   {
     try
     {
+      #ifdef _WIN32
+      My_SetDefaultDllDirectories();
+      #endif
       return WinMain2(nCmdShow);
     }
     catch (...)

CPP/7zip/UI/FileManager/FM.dsp

@@ -712,10 +712,24 @@ SOURCE=..\..\..\..\C\Alloc.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\CpuArch.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\CpuArch.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\Sort.c
 # SUBTRACT CPP /YX /Yc /Yu
 # End Source File

CPP/7zip/UI/FileManager/FM.mak

@@ -1,3 +1,16 @@
+CFLAGS = $(CFLAGS) \
+  -DLANG \
+  -DNEW_FOLDER_INTERFACE \
+
+!IFDEF UNDER_CE
+LIBS = $(LIBS) ceshell.lib Commctrl.lib
+!ELSE
+LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
+CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -DSUPPORT_DEVICE_FILE
+LFLAGS = $(LFLAGS) /DELAYLOAD:mpr.dll 
+LIBS = $(LIBS) delayimp.lib 
+!ENDIF
+
 FM_OBJS = \
   $O\App.obj \
   $O\BrowseDialog.obj \
@@ -73,6 +86,9 @@ WIN_OBJS = $(WIN_OBJS) \
 
 !ENDIF
 
+C_OBJS = $(C_OBJS) \
+  $O\DllSecur.obj \
+
 AGENT_OBJS = \
   $O\Agent.obj \
   $O\AgentOut.obj \

CPP/7zip/UI/FileManager/FSFolder.cpp

@@ -532,9 +532,8 @@ STDMETHODIMP CFSFolder::GetNumRawProps(UInt32 *numProps)
   return S_OK;
 }
 
-STDMETHODIMP CFSFolder::GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID)
+STDMETHODIMP CFSFolder::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID)
 {
-  index = index;
   *name = NULL;
   *propID = kpidNtReparse;
   return S_OK;

CPP/7zip/UI/FileManager/FSFolderCopy.cpp

@@ -161,8 +161,6 @@ static DWORD CALLBACK CopyProgressRoutine(
   LPVOID lpData                         // from CopyFileEx
 )
 {
-  TotalFileSize = TotalFileSize;
-  // TotalBytesTransferred = TotalBytesTransferred;
   // StreamSize = StreamSize;
   // StreamBytesTransferred = StreamBytesTransferred;
   // dwStreamNumber = dwStreamNumber;

CPP/7zip/UI/FileManager/makefile

@@ -1,16 +1,7 @@
 PROG = 7zFM.exe
 CFLAGS = $(CFLAGS) \
-  -DLANG \
-  -DNEW_FOLDER_INTERFACE \
   -DEXTERNAL_CODECS \
 
-!IFDEF UNDER_CE
-LIBS = $(LIBS) ceshell.lib Commctrl.lib
-!ELSE
-LIBS = $(LIBS) comctl32.lib htmlhelp.lib comdlg32.lib Mpr.lib Gdi32.lib
-CFLAGS = $(CFLAGS) -DWIN_LONG_PATH -DSUPPORT_DEVICE_FILE
-!ENDIF
-
 !include "FM.mak"
 
 COMMON_OBJS = \
@@ -102,8 +93,9 @@ GUI_OBJS = \
 COMPRESS_OBJS = \
   $O\CopyCoder.obj \
 
-C_OBJS = \
+C_OBJS = $(C_OBJS) \
   $O\Alloc.obj \
+  $O\CpuArch.obj \
   $O\Sort.obj \
   $O\Threads.obj \
 

CPP/7zip/UI/GUI/GUI.cpp

@@ -2,6 +2,10 @@
 
 #include "StdAfx.h"
 
+#ifdef _WIN32
+#include "../../../../C/DllSecur.h"
+#endif
+
 #include "../../../Common/MyWindows.h"
 
 #include <shlwapi.h>
@@ -372,6 +376,10 @@ int APIENTRY WinMain(HINSTANCE  hInstance, HINSTANCE /* hPrevInstance */,
   // setlocale(LC_COLLATE, ".ACP");
   try
   {
+    #ifdef _WIN32
+    My_SetDefaultDllDirectories();
+    #endif
+
     return Main2();
   }
   catch(const CNewException &)

CPP/7zip/UI/GUI/GUI.dsp

@@ -810,6 +810,15 @@ SOURCE=..\..\..\..\C\CpuArch.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\..\C\DllSecur.c
+# SUBTRACT CPP /YX /Yc /Yu
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\C\DllSecur.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\..\..\..\C\Sort.c
 
 !IF  "$(CFG)" == "GUI - Win32 Release"

CPP/7zip/UI/GUI/makefile

@@ -134,6 +134,7 @@ COMPRESS_OBJS = \
 C_OBJS = \
   $O\Alloc.obj \
   $O\CpuArch.obj \
+  $O\DllSecur.obj \
   $O\Sort.obj \
   $O\Threads.obj \
 

CPP/Build.mak

@@ -67,6 +67,10 @@ CFLAGS = $(CFLAGS) -MP2
 CFLAGS = $(CFLAGS)
 !ENDIF
 
+!IFDEF MY_CONSOLE
+CFLAGS = $(CFLAGS) -D_CONSOLE
+!ENDIF
+
 !IFNDEF UNDER_CE
 !IF "$(PLATFORM)" == "arm"
 CFLAGS = $(CFLAGS) -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE

CPP/Common/ListFileUtils.cpp

@@ -107,7 +107,7 @@ bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePag
   }
 
   const wchar_t kGoodBOM = 0xFEFF;
-  const wchar_t kBadBOM  = 0xFFFE;
+  // const wchar_t kBadBOM  = 0xFFFE;
   
   UString s;
   unsigned i = 0;
@@ -115,8 +115,10 @@ bool ReadNamesFromListFile2(CFSTR fileName, UStringVector &strings, UINT codePag
   for (; i < u.Len(); i++)
   {
     wchar_t c = u[i];
+    /*
     if (c == kGoodBOM || c == kBadBOM)
       return false;
+    */
     if (c == '\n' || c == 0xD)
     {
       AddName(strings, s);

CPP/Common/MyBuffer2.h

@@ -5,7 +5,7 @@
 
 #include "../../C/Alloc.h"
 
-#include "Defs.h"
+#include "MyTypes.h"
 
 class CMidBuffer
 {
@@ -15,7 +15,7 @@ class CMidBuffer
   CLASS_NO_COPY(CMidBuffer)
 
 public:
-  CMidBuffer(): _data(NULL), _size(0) {};
+  CMidBuffer(): _data(NULL), _size(0) {}
   ~CMidBuffer() { ::MidFree(_data); }
 
   void Free() { ::MidFree(_data); _data = NULL; _size = 0; }
@@ -29,12 +29,12 @@ public:
   {
     if (!_data || size > _size)
     {
+      ::MidFree(_data);
       const size_t kMinSize = (size_t)1 << 16;
       if (size < kMinSize)
         size = kMinSize;
-      ::MidFree(_data);
       _size = 0;
-      _data = 0;
+      _data = NULL;
       _data = (Byte *)::MidAlloc(size);
       if (_data)
         _size = size;
@@ -42,4 +42,59 @@ public:
   }
 };
 
+
+class CAlignedBuffer
+{
+  Byte *_data;
+  size_t _size;
+
+  CLASS_NO_COPY(CAlignedBuffer)
+
+public:
+  CAlignedBuffer(): _data(NULL), _size(0) {}
+  ~CAlignedBuffer()
+  {
+    ISzAlloc_Free(&g_AlignedAlloc, _data);
+  }
+
+  void Free()
+  {
+    ISzAlloc_Free(&g_AlignedAlloc, _data);
+    _data = NULL;
+    _size = 0;
+  }
+
+  bool IsAllocated() const { return _data != NULL; }
+  operator       Byte *()       { return _data; }
+  operator const Byte *() const { return _data; }
+  size_t Size() const { return _size; }
+
+  void Alloc(size_t size)
+  {
+    if (!_data || size != _size)
+    {
+      ISzAlloc_Free(&g_AlignedAlloc, _data);
+      _size = 0;
+      _data = NULL;
+      _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+      if (_data)
+        _size = size;
+    }
+  }
+
+  void AllocAtLeast(size_t size)
+  {
+    if (!_data || size > _size)
+    {
+      ISzAlloc_Free(&g_AlignedAlloc, _data);
+      _size = 0;
+      _data = NULL;
+      _data = (Byte *)ISzAlloc_Alloc(&g_AlignedAlloc, size);
+      if (_data)
+        _size = size;
+    }
+  }
+};
+
+
 #endif

CPP/Windows/MemoryLock.cpp

@@ -2,6 +2,8 @@
 
 #include "StdAfx.h"
 
+#include "../../C/CpuArch.h"
+
 #include "MemoryLock.h"
 
 namespace NWindows {
@@ -75,6 +77,9 @@ typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
   We suppose that Window 10 works incorrectly with "Large Pages" at:
     - Windows 10 1703 (15063)
     - Windows 10 1709 (16299)
+
+    - Windows 10 1809 (17763) on some CPUs that have no 1 GB page support.
+         We need more information about that new BUG in Windows.
 */
 
 unsigned Get_LargePages_RiskLevel()
@@ -87,9 +92,19 @@ unsigned Get_LargePages_RiskLevel()
   if (!func)
     return 0;
   func(&vi);
-  return (vi.dwPlatformId == VER_PLATFORM_WIN32_NT
-      && vi.dwMajorVersion + vi.dwMinorVersion == 10
-      && vi.dwBuildNumber <= 16299) ? 1 : 0;
+  if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
+    return 0;
+  if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
+    return 0;
+  if (vi.dwBuildNumber <= 16299)
+    return 1;
+
+  #ifdef MY_CPU_X86_OR_AMD64
+  if (!CPU_IsSupported_PageGB())
+    return 1;
+  #endif
+
+  return 0;
 }
 
 #endif

CPP/Windows/Shell.cpp

@@ -2,6 +2,11 @@
 
 #include "StdAfx.h"
 
+/*
+#include <stdio.h>
+#include <string.h>
+*/
+
 #include "../Common/MyCom.h"
 #ifndef _UNICODE
 #include "../Common/StringConvert.h"
@@ -114,9 +119,22 @@ UString CDrop::QueryFileName(UINT fileIndex)
 void CDrop::QueryFileNames(UStringVector &fileNames)
 {
   UINT numFiles = QueryCountOfFiles();
+  /*
+  char s[100];
+  sprintf(s, "QueryFileNames: %d files", numFiles);
+  OutputDebugStringA(s);
+  */
   fileNames.ClearAndReserve(numFiles);
   for (UINT i = 0; i < numFiles; i++)
-    fileNames.AddInReserved(QueryFileName(i));
+  {
+    const UString s2 = QueryFileName(i);
+    if (!s2.IsEmpty())
+      fileNames.AddInReserved(s2);
+    /*
+    OutputDebugStringW(L"file ---");
+    OutputDebugStringW(s2);
+    */
+  }
 }