1 files changed, 189 insertions, 22 deletions

diff --git a/src/libs/7zip/win/CPP/7zip/Archive/7z/7zOut.h b/src/libs/7zip/win/CPP/7zip/Archive/7z/7zOut.h
index 7b1b528e6..391ca9d02 100644
--- a/src/libs/7zip/win/CPP/7zip/Archive/7z/7zOut.h
+++ b/src/libs/7zip/win/CPP/7zip/Archive/7z/7zOut.h
@@ -9,6 +9,7 @@
 #include "7zItem.h"
 
 #include "../../Common/OutBuffer.h"
+#include "../../Common/StreamUtils.h"
 
 namespace NArchive {
 namespace N7z {
@@ -45,27 +46,191 @@ public:
 struct CHeaderOptions
 {
   bool CompressMainHeader;
+  /*
   bool WriteCTime;
   bool WriteATime;
   bool WriteMTime;
+  */
 
   CHeaderOptions():
-      CompressMainHeader(true),
-      WriteCTime(false),
-      WriteATime(false),
-      WriteMTime(true)
+      CompressMainHeader(true)
+      /*
+      , WriteCTime(false)
+      , WriteATime(false)
+      , WriteMTime(true)
+      */
       {}
 };
 
+
+struct CFileItem2
+{
+  UInt64 CTime;
+  UInt64 ATime;
+  UInt64 MTime;
+  UInt64 StartPos;
+  bool CTimeDefined;
+  bool ATimeDefined;
+  bool MTimeDefined;
+  bool StartPosDefined;
+  bool IsAnti;
+  // bool IsAux;
+
+  void Init()
+  {
+    CTimeDefined = false;
+    ATimeDefined = false;
+    MTimeDefined = false;
+    StartPosDefined = false;
+    IsAnti = false;
+    // IsAux = false;
+  }
+};
+
+struct COutFolders
+{
+  CUInt32DefVector FolderUnpackCRCs; // Now we use it for headers only.
+
+  CRecordVector<CNum> NumUnpackStreamsVector;
+  CRecordVector<UInt64> CoderUnpackSizes; // including unpack sizes of bind coders
+
+  void OutFoldersClear()
+  {
+    FolderUnpackCRCs.Clear();
+    NumUnpackStreamsVector.Clear();
+    CoderUnpackSizes.Clear();
+  }
+
+  void OutFoldersReserveDown()
+  {
+    FolderUnpackCRCs.ReserveDown();
+    NumUnpackStreamsVector.ReserveDown();
+    CoderUnpackSizes.ReserveDown();
+  }
+};
+
+struct CArchiveDatabaseOut: public COutFolders
+{
+  CRecordVector<UInt64> PackSizes;
+  CUInt32DefVector PackCRCs;
+  CObjectVector<CFolder> Folders;
+
+  CRecordVector<CFileItem> Files;
+  UStringVector Names;
+  CUInt64DefVector CTime;
+  CUInt64DefVector ATime;
+  CUInt64DefVector MTime;
+  CUInt64DefVector StartPos;
+  CRecordVector<bool> IsAnti;
+
+  /*
+  CRecordVector<bool> IsAux;
+
+  CByteBuffer SecureBuf;
+  CRecordVector<UInt32> SecureSizes;
+  CRecordVector<UInt32> SecureIDs;
+
+  void ClearSecure()
+  {
+    SecureBuf.Free();
+    SecureSizes.Clear();
+    SecureIDs.Clear();
+  }
+  */
+
+  void Clear()
+  {
+    OutFoldersClear();
+
+    PackSizes.Clear();
+    PackCRCs.Clear();
+    Folders.Clear();
+
+    Files.Clear();
+    Names.Clear();
+    CTime.Clear();
+    ATime.Clear();
+    MTime.Clear();
+    StartPos.Clear();
+    IsAnti.Clear();
+
+    /*
+    IsAux.Clear();
+    ClearSecure();
+    */
+  }
+
+  void ReserveDown()
+  {
+    OutFoldersReserveDown();
+
+    PackSizes.ReserveDown();
+    PackCRCs.ReserveDown();
+    Folders.ReserveDown();
+
+    Files.ReserveDown();
+    Names.ReserveDown();
+    CTime.ReserveDown();
+    ATime.ReserveDown();
+    MTime.ReserveDown();
+    StartPos.ReserveDown();
+    IsAnti.ReserveDown();
+
+    /*
+    IsAux.ReserveDown();
+    */
+  }
+
+  bool IsEmpty() const
+  {
+    return (
+      PackSizes.IsEmpty() &&
+      NumUnpackStreamsVector.IsEmpty() &&
+      Folders.IsEmpty() &&
+      Files.IsEmpty());
+  }
+
+  bool CheckNumFiles() const
+  {
+    unsigned size = Files.Size();
+    return (
+      CTime.CheckSize(size) &&
+      ATime.CheckSize(size) &&
+      MTime.CheckSize(size) &&
+      StartPos.CheckSize(size) &&
+      (size == IsAnti.Size() || IsAnti.Size() == 0));
+  }
+
+  bool IsItemAnti(unsigned index) const { return (index < IsAnti.Size() && IsAnti[index]); }
+  // bool IsItemAux(unsigned index) const { return (index < IsAux.Size() && IsAux[index]); }
+
+  void SetItem_Anti(unsigned index, bool isAnti)
+  {
+    while (index >= IsAnti.Size())
+      IsAnti.Add(false);
+    IsAnti[index] = isAnti;
+  }
+  /*
+  void SetItem_Aux(unsigned index, bool isAux)
+  {
+    while (index >= IsAux.Size())
+      IsAux.Add(false);
+    IsAux[index] = isAux;
+  }
+  */
+
+  void AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name);
+};
+
 class COutArchive
 {
   UInt64 _prefixHeaderPos;
 
-  HRESULT WriteDirect(const void *data, UInt32 size);
-  
+  HRESULT WriteDirect(const void *data, UInt32 size) { return WriteStream(SeqStream, data, size); }
+
   UInt64 GetPos() const;
   void WriteBytes(const void *data, size_t size);
-  void WriteBytes(const CByteBuffer &data) { WriteBytes(data, data.GetCapacity()); }
+  void WriteBytes(const CByteBuffer &data) { WriteBytes(data, data.Size()); }
   void WriteByte(Byte b);
   void WriteUInt32(UInt32 value);
   void WriteUInt64(UInt64 value);
@@ -75,38 +240,38 @@ class COutArchive
   void WriteFolder(const CFolder &folder);
   HRESULT WriteFileHeader(const CFileItem &itemInfo);
   void WriteBoolVector(const CBoolVector &boolVector);
-  void WriteHashDigests(
-      const CRecordVector<bool> &digestsDefined,
-      const CRecordVector<UInt32> &hashDigests);
+  void WritePropBoolVector(Byte id, const CBoolVector &boolVector);
+
+  void WriteHashDigests(const CUInt32DefVector &digests);
 
   void WritePackInfo(
       UInt64 dataOffset,
       const CRecordVector<UInt64> &packSizes,
-      const CRecordVector<bool> &packCRCsDefined,
-      const CRecordVector<UInt32> &packCRCs);
+      const CUInt32DefVector &packCRCs);
 
-  void WriteUnpackInfo(const CObjectVector<CFolder> &folders);
+  void WriteUnpackInfo(
+      const CObjectVector<CFolder> &folders,
+      const COutFolders &outFolders);
 
   void WriteSubStreamsInfo(
       const CObjectVector<CFolder> &folders,
-      const CRecordVector<CNum> &numUnpackStreamsInFolders,
+      const COutFolders &outFolders,
       const CRecordVector<UInt64> &unpackSizes,
-      const CRecordVector<bool> &digestsDefined,
-      const CRecordVector<UInt32> &hashDigests);
+      const CUInt32DefVector &digests);
 
   void SkipAlign(unsigned pos, unsigned alignSize);
-  void WriteAlignedBoolHeader(const CBoolVector &v, int numDefined, Byte type, unsigned itemSize);
+  void WriteAlignedBoolHeader(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSize);
   void WriteUInt64DefVector(const CUInt64DefVector &v, Byte type);
 
   HRESULT EncodeStream(
       DECL_EXTERNAL_CODECS_LOC_VARS
       CEncoder &encoder, const CByteBuffer &data,
-      CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders);
+      CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders);
   void WriteHeader(
-      const CArchiveDatabase &db,
-      const CHeaderOptions &headerOptions,
+      const CArchiveDatabaseOut &db,
+      // const CHeaderOptions &headerOptions,
       UInt64 &headerOffset);
-  
+
   bool _countMode;
   bool _writeToStream;
   size_t _countSize;
@@ -118,6 +283,8 @@ class COutArchive
   bool _endMarker;
   #endif
 
+  bool _useAlign;
+
   HRESULT WriteSignature();
   #ifdef _7Z_VOL
   HRESULT WriteFinishSignature();
@@ -136,7 +303,7 @@ public:
   HRESULT SkipPrefixArchiveHeader();
   HRESULT WriteDatabase(
       DECL_EXTERNAL_CODECS_LOC_VARS
-      const CArchiveDatabase &db,
+      const CArchiveDatabaseOut &db,
       const CCompressionMethodMode *options,
       const CHeaderOptions &headerOptions);