7zip-native 0.0.0-stage → 0.0.5

package/vendor/7zip/CPP/7zip/UI/Far/ProgressBox.cpp

@@ -0,0 +1,305 @@
+// ProgressBox.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
+
+#include "FarUtils.h"
+#include "ProgressBox.h"
+
+void CPercentPrinterState::ClearCurState()
+{
+  Completed = 0;
+  Total = ((UInt64)(Int64)-1);
+  Files = 0;
+  FilesTotal = 0;
+  Command.Empty();
+  FileName.Empty();
+}
+
+void CProgressBox::Init(const char *title)
+{
+  _title = title;
+  _wasPrinted = false;
+  StartTick = GetTickCount();
+  _prevTick = StartTick;
+  _prevElapsedSec = 0;
+}
+
+static unsigned GetPower32(UInt32 val)
+{
+  const unsigned kStart = 32;
+  UInt32 mask = ((UInt32)1 << (kStart - 1));
+  for (unsigned i = kStart;; i--)
+  {
+    if (i == 0 || (val & mask) != 0)
+      return i;
+    mask >>= 1;
+  }
+}
+
+static unsigned GetPower64(UInt64 val)
+{
+  UInt32 high = (UInt32)(val >> 32);
+  if (high == 0)
+    return GetPower32((UInt32)val);
+  return GetPower32(high) + 32;
+}
+
+static UInt64 MyMultAndDiv(UInt64 mult1, UInt64 mult2, UInt64 divider)
+{
+  unsigned pow1 = GetPower64(mult1);
+  unsigned pow2 = GetPower64(mult2);
+  while (pow1 + pow2 > 64)
+  {
+    if (pow1 > pow2) { pow1--; mult1 >>= 1; }
+    else             { pow2--; mult2 >>= 1; }
+    divider >>= 1;
+  }
+  UInt64 res = mult1 * mult2;
+  if (divider != 0)
+    res /= divider;
+  return res;
+}
+
+#define UINT_TO_STR_2(val) { s[0] = (char)('0' + (val) / 10); s[1] = (char)('0' + (val) % 10); s += 2; }
+
+static void GetTimeString(UInt64 timeValue, char *s)
+{
+  const UInt64 hours = timeValue / 3600;
+  UInt32 seconds = (UInt32)(timeValue - hours * 3600);
+  const UInt32 minutes = seconds / 60;
+  seconds %= 60;
+  if (hours > 99)
+  {
+    ConvertUInt64ToString(hours, s);
+    for (; *s != 0; s++);
+  }
+  else
+  {
+    const UInt32 hours32 = (UInt32)hours;
+    UINT_TO_STR_2(hours32)
+  }
+  *s++ = ':'; UINT_TO_STR_2(minutes)
+  *s++ = ':'; UINT_TO_STR_2(seconds)
+  *s = 0;
+}
+
+void CProgressBox::ReduceString(const UString &src, AString &dest)
+{
+  UnicodeStringToMultiByte2(dest, src, CP_OEMCP);
+
+  if (dest.Len() <= MaxLen)
+    return;
+  unsigned len = FileName.Len();
+  for (; len != 0;)
+  {
+    unsigned delta = len / 8;
+    if (delta == 0)
+      delta = 1;
+    len -= delta;
+    _tempU = FileName;
+    _tempU.Delete(len / 2, FileName.Len() - len);
+    _tempU.Insert(len / 2, L" . ");
+    UnicodeStringToMultiByte2(dest, _tempU, CP_OEMCP);
+    if (dest.Len() <= MaxLen)
+      return;
+  }
+  dest.Empty();
+}
+
+static void Print_UInt64_and_String(AString &s, UInt64 val, const char *name)
+{
+  char temp[32];
+  ConvertUInt64ToString(val, temp);
+  s += temp;
+  s.Add_Space();
+  s += name;
+}
+
+
+static void PrintSize_bytes_Smart(AString &s, UInt64 val)
+{
+  // Print_UInt64_and_String(s, val, "bytes");
+  {
+    char temp[32];
+    ConvertUInt64ToString(val, temp);
+    s += temp;
+  }
+
+  if (val == 0)
+    return;
+
+  unsigned numBits = 10;
+  char c = 'K';
+  char temp[4] = { 'K', 'i', 'B', 0 };
+       if (val >= ((UInt64)10 << 30)) { numBits = 30; c = 'G'; }
+  else if (val >= ((UInt64)10 << 20)) { numBits = 20; c = 'M'; }
+  temp[0] = c;
+  s += " (";
+  Print_UInt64_and_String(s, ((val + ((UInt64)1 << numBits) - 1) >> numBits), temp);
+  s += ')';
+}
+
+
+static const unsigned kPercentsSize = 4;
+
+void CProgressBox::Print()
+{
+  DWORD tick = GetTickCount();
+  DWORD elapsedTicks = tick - StartTick;
+  DWORD elapsedSec = elapsedTicks / 1000;
+
+  if (_wasPrinted)
+  {
+    if (elapsedSec == _prevElapsedSec)
+    {
+      if ((UInt32)(tick - _prevTick) < _tickStep)
+        return;
+      if (_printedState.IsEqualTo((const CPercentPrinterState &)*this))
+        return;
+    }
+  }
+
+  UInt64 cur = Completed;
+  UInt64 total = Total;
+
+  if (!UseBytesForPercents)
+  {
+    cur = Files;
+    total = FilesTotal;
+  }
+
+  {
+    _timeStr.Empty();
+    _timeStr = "Elapsed time: ";
+    char s[40];
+    GetTimeString(elapsedSec, s);
+    _timeStr += s;
+
+    if (cur != 0)
+    {
+      UInt64 remainingTime = 0;
+      if (cur < total)
+        remainingTime = MyMultAndDiv(elapsedTicks, total - cur, cur);
+      UInt64 remainingSec = remainingTime / 1000;
+      _timeStr += "    Remaining time: ";
+      
+      GetTimeString(remainingSec, s);
+      _timeStr += s;
+    }
+  }
+
+
+  {
+    _perc.Empty();
+    char s[32];
+    unsigned size;
+    {
+      UInt64 val = 0;
+      if (total != (UInt64)(Int64)-1 && total != 0)
+        val = cur * 100 / Total;
+      
+      ConvertUInt64ToString(val, s);
+      size = (unsigned)strlen(s);
+      s[size++] = '%';
+      s[size] = 0;
+    }
+    
+    unsigned len = size;
+    while (len < kPercentsSize)
+      len = kPercentsSize;
+    len++;
+    
+    if (len < MaxLen)
+    {
+      unsigned numChars = MaxLen - len;
+      unsigned filled = 0;
+      if (total != (UInt64)(Int64)-1 && total != 0)
+        filled = (unsigned)(cur * numChars / total);
+      if (filled > numChars)
+        filled = numChars;
+      unsigned i = 0;
+      for (i = 0; i < filled; i++)
+        _perc += (char)(Byte)0xDB; // '=';
+      for (; i < numChars; i++)
+        _perc += (char)(Byte)0xB0; // '.';
+    }
+    
+    _perc.Add_Space();
+    while (size < kPercentsSize)
+    {
+      _perc.Add_Space();
+      size++;
+    }
+    _perc += s;
+  }
+
+  _files.Empty();
+  if (Files != 0 || FilesTotal != 0)
+  {
+    _files += "Files: ";
+    char s[32];
+    // if (Files != 0)
+    {
+      ConvertUInt64ToString(Files, s);
+      _files += s;
+    }
+    if (FilesTotal != 0)
+    {
+      _files += " / ";
+      ConvertUInt64ToString(FilesTotal, s);
+      _files += s;
+    }
+  }
+
+  _sizesStr.Empty();
+  if (Total != 0)
+  {
+    _sizesStr += "Size: ";
+    PrintSize_bytes_Smart(_sizesStr, Completed);
+    if (Total != 0 && Total != (UInt64)(Int64)-1)
+    {
+      _sizesStr += " / ";
+      PrintSize_bytes_Smart(_sizesStr, Total);
+    }
+  }
+
+  _name1.Empty();
+  _name2.Empty();
+
+  if (!FileName.IsEmpty())
+  {
+    _name1U.Empty();
+    _name2U.Empty();
+
+    /*
+    if (_isDir)
+      s1 = _filePath;
+    else
+    */
+    {
+      const int slashPos = FileName.ReverseFind_PathSepar();
+      if (slashPos >= 0)
+      {
+        _name1U.SetFrom(FileName, (unsigned)(slashPos + 1));
+        _name2U = FileName.Ptr(slashPos + 1);
+      }
+      else
+        _name2U = FileName;
+    }
+    ReduceString(_name1U, _name1);
+    ReduceString(_name2U, _name2);
+  }
+  
+  {
+    const char *strings[] = { _title, _timeStr, _files, _sizesStr, Command, _name1, _name2, _perc };
+    NFar::g_StartupInfo.ShowMessage(FMSG_LEFTALIGN, NULL, strings, Z7_ARRAY_SIZE(strings), 0);
+  }
+
+  _wasPrinted = true;
+  _printedState = *this;
+  _prevTick = tick;
+  _prevElapsedSec = elapsedSec;
+}

package/vendor/7zip/CPP/7zip/UI/Far/ProgressBox.h

@@ -0,0 +1,85 @@
+// ProgressBox.h
+
+#ifndef ZIP7_INC_PROGRESS_BOX_H
+#define ZIP7_INC_PROGRESS_BOX_H
+
+#include "../../../Common/MyString.h"
+#include "../../../Common/MyTypes.h"
+
+struct CPercentPrinterState
+{
+  UInt64 Completed;
+  UInt64 Total;
+  
+  UInt64 Files;
+  UInt64 FilesTotal;
+
+  AString Command;
+  UString FileName;
+
+  void ClearCurState();
+
+  bool IsEqualTo(const CPercentPrinterState &s) const
+  {
+    return
+           Completed == s.Completed
+        && Total == s.Total
+        && Files == s.Files
+        && FilesTotal == s.FilesTotal
+        && Command == s.Command
+        && FileName == s.FileName;
+  }
+
+  CPercentPrinterState():
+      Completed(0),
+      Total((UInt64)(Int64)-1),
+      Files(0),
+      FilesTotal(0)
+    {}
+};
+
+class CProgressBox: public CPercentPrinterState
+{
+  UInt32 _tickStep;
+  DWORD _prevTick;
+  DWORD _prevElapsedSec;
+
+  bool _wasPrinted;
+public:
+  bool UseBytesForPercents;
+  DWORD StartTick;
+  unsigned MaxLen;
+
+private:
+  UString _tempU;
+  UString _name1U;
+  UString _name2U;
+
+  CPercentPrinterState _printedState;
+
+  AString _title;
+  
+  AString _timeStr;
+  AString _files;
+  AString _sizesStr;
+  AString _name1;
+  AString _name2;
+  AString _perc;
+
+  void ReduceString(const UString &src, AString &dest);
+
+public:
+
+  CProgressBox(UInt32 tickStep = 200):
+      _tickStep(tickStep),
+      _prevTick(0),
+      UseBytesForPercents(true),
+      StartTick(0),
+      MaxLen(60)
+    {}
+
+  void Init(const char *title);
+  void Print();
+};
+
+#endif

package/vendor/7zip/CPP/7zip/UI/Far/StdAfx.cpp

@@ -0,0 +1,3 @@
+// StdAfx.cpp
+
+#include "StdAfx.h"

package/vendor/7zip/CPP/7zip/UI/Far/StdAfx.h

@@ -0,0 +1,11 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+#include "../../../Common/Common.h"
+
+#endif

package/vendor/7zip/CPP/7zip/UI/Far/UpdateCallbackFar.cpp

@@ -0,0 +1,327 @@
+// UpdateCallbackFar.cpp
+
+#include "StdAfx.h"
+
+#ifndef Z7_ST
+#include "../../../Windows/Synchronization.h"
+#endif
+
+#include "../../../Common/StringConvert.h"
+
+#include "FarUtils.h"
+#include "UpdateCallbackFar.h"
+
+using namespace NWindows;
+using namespace NFar;
+
+#ifndef Z7_ST
+static NSynchronization::CCriticalSection g_CriticalSection;
+#define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection);
+#else
+#define MT_LOCK
+#endif
+
+static HRESULT CheckBreak2()
+{
+  return WasEscPressed() ? E_ABORT : S_OK;
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanProgress(UInt64 numFolders, UInt64 numFiles, UInt64 totalSize, const wchar_t *path, Int32 /* isDir */))
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    _percent->FilesTotal = numFolders + numFiles;
+    _percent->Total = totalSize;
+    _percent->Command = "Scanning";
+    _percent->FileName = path;
+    _percent->Print();
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ScanError(const wchar_t *path, HRESULT errorCode))
+{
+  if (ShowSysErrorMessage(errorCode, path) == -1)
+    return E_ABORT;
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetNumFiles(UInt64 numFiles))
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    _percent->FilesTotal = numFiles;
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */))
+{
+  MT_LOCK
+  return CheckBreak2();
+}
+
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetTotal(UInt64 size))
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    _percent->Total = size;
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::SetCompleted(const UInt64 *completeValue))
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    if (completeValue)
+      _percent->Completed = *completeValue;
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CompressOperation(const wchar_t *name))
+{
+  MT_LOCK
+  
+  if (_percent)
+  {
+    _percent->Command = "Adding";
+    _percent->FileName = name;
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::DeleteOperation(const wchar_t *name))
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    _percent->Command = "Deleting";
+    _percent->FileName = name;
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OperationResult(Int32 /* opRes */))
+{
+  MT_LOCK
+  
+  if (_percent)
+  {
+    _percent->Files++;
+  }
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::UpdateErrorMessage(const wchar_t *message))
+{
+  MT_LOCK
+
+  if (g_StartupInfo.ShowErrorMessage(UnicodeStringToMultiByte(message, CP_OEMCP)) == -1)
+    return E_ABORT;
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::OpenFileError(const wchar_t *path, HRESULT errorCode))
+{
+  if (ShowSysErrorMessage(errorCode, path) == -1)
+    return E_ABORT;
+  return CheckBreak2();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReadingFileError(const wchar_t *path, HRESULT errorCode))
+{
+  if (ShowSysErrorMessage(errorCode, path) == -1)
+    return E_ABORT;
+  return CheckBreak2();
+}
+
+void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, AString &s);
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportExtractResult(Int32 opRes, Int32 isEncrypted, const wchar_t *name))
+{
+  MT_LOCK
+
+  if (opRes != NArchive::NExtract::NOperationResult::kOK)
+  {
+    AString s;
+    SetExtractErrorMessage(opRes, isEncrypted, s);
+    if (PrintErrorMessage(s, name) == -1)
+      return E_ABORT;
+  }
+
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::ReportUpdateOperation(UInt32 op, const wchar_t *name, Int32 /* isDir */))
+{
+  const char *s;
+  switch (op)
+  {
+    case NUpdateNotifyOp::kAdd: s = "Adding"; break;
+    case NUpdateNotifyOp::kUpdate: s = "Updating"; break;
+    case NUpdateNotifyOp::kAnalyze: s = "Analyzing"; break;
+    case NUpdateNotifyOp::kReplicate: s = "Replicating"; break;
+    case NUpdateNotifyOp::kRepack: s = "Repacking"; break;
+    case NUpdateNotifyOp::kSkip: s = "Skipping"; break;
+    case NUpdateNotifyOp::kHeader: s = "Header creating"; break;
+    case NUpdateNotifyOp::kDelete: s = "Deleting"; break;
+    default: s = "Unknown operation";
+  }
+
+  MT_LOCK
+
+  if (_percent)
+  {
+    _percent->Command = s;
+    _percent->FileName.Empty();
+    if (name)
+      _percent->FileName = name;
+    _percent->Print();
+  }
+  
+  return CheckBreak2();
+}
+
+
+HRESULT CUpdateCallback100Imp::MoveArc_UpdateStatus()
+{
+  MT_LOCK
+
+  if (_percent)
+  {
+    AString s;
+    s.Add_UInt64(_arcMoving_percents);
+    // status.Add_Space();
+    s.Add_Char('%');
+    const bool totalDefined = (_arcMoving_total != 0 && _arcMoving_total != (UInt64)(Int64)-1);
+    if (_arcMoving_current != 0 || totalDefined)
+    {
+      s += " : ";
+      s.Add_UInt64(_arcMoving_current >> 20);
+      s += " MiB";
+    }
+    if (totalDefined)
+    {
+      s += " / ";
+      s.Add_UInt64((_arcMoving_total + ((1 << 20) - 1)) >> 20);
+      s += " MiB";
+    }
+    s += " : temporary archive moving ...";
+    _percent->Command =  s;
+    _percent->Print();
+  }
+
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Start(const wchar_t *srcTempPath, const wchar_t * /* destFinalPath */ , UInt64 size, Int32 /* updateMode */))
+{
+  MT_LOCK
+
+  _arcMoving_total = size;
+  _arcMoving_current = 0;
+  _arcMoving_percents = 0;
+  // _arcMoving_updateMode = updateMode;
+  // _name2 = fs2us(destFinalPath);
+  if (_percent)
+    _percent->FileName = srcTempPath;
+  return MoveArc_UpdateStatus();
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Progress(UInt64 totalSize, UInt64 currentSize))
+{
+  UInt64 percents = 0;
+  if (totalSize != 0)
+  {
+    if (totalSize < ((UInt64)1 << 57))
+      percents = currentSize * 100 / totalSize;
+    else
+      percents = currentSize / (totalSize / 100);
+  }
+
+#ifdef _WIN32
+  // Sleep(300); // for debug
+#endif
+  if (percents == _arcMoving_percents)
+    return CheckBreak2();
+  _arcMoving_total = totalSize;
+  _arcMoving_current = currentSize;
+  _arcMoving_percents = percents;
+  // if (_arcMoving_percents > 100) return E_FAIL;
+  return MoveArc_UpdateStatus();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::MoveArc_Finish())
+{
+  // _arcMoving_percents = 0;
+  if (_percent)
+  {
+    _percent->Command.Empty();
+    _percent->FileName.Empty();
+    _percent->Print();
+  }
+  return CheckBreak2();
+}
+
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::Before_ArcReopen())
+{
+  // fixme: we can use Clear_Stop_Status() here
+  return CheckBreak2();
+}
+
+
+extern HRESULT GetPassword(UString &password);
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword(BSTR *password))
+{
+  MT_LOCK
+
+  *password = NULL;
+  if (!PasswordIsDefined)
+  {
+    RINOK(GetPassword(Password))
+    PasswordIsDefined = true;
+  }
+  return StringToBstr(Password, password);
+}
+
+Z7_COM7F_IMF(CUpdateCallback100Imp::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password))
+{
+  MT_LOCK
+
+  *password = NULL;
+  *passwordIsDefined = BoolToInt(PasswordIsDefined);
+  if (!PasswordIsDefined)
+    return S_OK;
+  return StringToBstr(Password, password);
+}