Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 335 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CPP/7zip/Archive/7z/7zOut.h b/other-licenses/7zstub/src/CPP/7zip/Archive/7z/7zOut.h
new file mode 100644
index 0000000000..12e965f861
--- /dev/null
+++ b/other-licenses/7zstub/src/CPP/7zip/Archive/7z/7zOut.h
@@ -0,0 +1,335 @@
+// 7zOut.h

+

+#ifndef __7Z_OUT_H

+#define __7Z_OUT_H

+

+#include "7zCompressionMode.h"

+#include "7zEncode.h"

+#include "7zHeader.h"

+#include "7zItem.h"

+

+#include "../../Common/OutBuffer.h"

+#include "../../Common/StreamUtils.h"

+

+namespace NArchive {

+namespace N7z {

+

+class CWriteBufferLoc

+{

+  Byte *_data;

+  size_t _size;

+  size_t _pos;

+public:

+  CWriteBufferLoc(): _size(0), _pos(0) {}

+  void Init(Byte *data, size_t size)

+  {

+    _data = data;

+    _size = size;

+    _pos = 0;

+  }

+  void WriteBytes(const void *data, size_t size)

+  {

+    if (size == 0)

+      return;

+    if (size > _size - _pos)

+      throw 1;

+    memcpy(_data + _pos, data, size);

+    _pos += size;

+  }

+  void WriteByte(Byte b)

+  {

+    if (_size == _pos)

+      throw 1;

+    _data[_pos++] = b;

+  }

+  size_t GetPos() const { return _pos; }

+};

+

+

+struct CHeaderOptions

+{

+  bool CompressMainHeader;

+  /*

+  bool WriteCTime;

+  bool WriteATime;

+  bool WriteMTime;

+  */

+

+  CHeaderOptions():

+      CompressMainHeader(true)

+      /*

+      , WriteCTime(false)

+      , WriteATime(false)

+      , WriteMTime(true)

+      */

+      {}

+};

+

+

+struct CFileItem2

+{

+  UInt64 CTime;

+  UInt64 ATime;

+  UInt64 MTime;

+  UInt64 StartPos;

+  UInt32 Attrib;

+

+  bool CTimeDefined;

+  bool ATimeDefined;

+  bool MTimeDefined;

+  bool StartPosDefined;

+  bool AttribDefined;

+  bool IsAnti;

+  // bool IsAux;

+

+  /*

+  void Init()

+  {

+    CTimeDefined = false;

+    ATimeDefined = false;

+    MTimeDefined = false;

+    StartPosDefined = false;

+    AttribDefined = 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 bond 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;

+  CUInt32DefVector Attrib;

+  CBoolVector IsAnti;

+

+  /*

+  CBoolVector 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();

+    Attrib.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();

+    Attrib.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)

+        && Attrib.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) { return WriteStream(SeqStream, data, size); }

+  

+  UInt64 GetPos() const;

+  void WriteBytes(const void *data, size_t size);

+  void WriteBytes(const CByteBuffer &data) { WriteBytes(data, data.Size()); }

+  void WriteByte(Byte b);

+  void WriteUInt32(UInt32 value);

+  void WriteUInt64(UInt64 value);

+  void WriteNumber(UInt64 value);

+  void WriteID(UInt64 value) { WriteNumber(value); }

+

+  void WriteFolder(const CFolder &folder);

+  HRESULT WriteFileHeader(const CFileItem &itemInfo);

+  void WriteBoolVector(const CBoolVector &boolVector);

+  void WritePropBoolVector(Byte id, const CBoolVector &boolVector);

+

+  void WriteHashDigests(const CUInt32DefVector &digests);

+

+  void WritePackInfo(

+      UInt64 dataOffset,

+      const CRecordVector<UInt64> &packSizes,

+      const CUInt32DefVector &packCRCs);

+

+  void WriteUnpackInfo(

+      const CObjectVector<CFolder> &folders,

+      const COutFolders &outFolders);

+

+  void WriteSubStreamsInfo(

+      const CObjectVector<CFolder> &folders,

+      const COutFolders &outFolders,

+      const CRecordVector<UInt64> &unpackSizes,

+      const CUInt32DefVector &digests);

+

+  void SkipToAligned(unsigned pos, unsigned alignShifts);

+  void WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts);

+  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, COutFolders &outFolders);

+  void WriteHeader(

+      const CArchiveDatabaseOut &db,

+      // const CHeaderOptions &headerOptions,

+      UInt64 &headerOffset);

+  

+  bool _countMode;

+  bool _writeToStream;

+  size_t _countSize;

+  UInt32 _crc;

+  COutBuffer _outByte;

+  CWriteBufferLoc _outByte2;

+

+  #ifdef _7Z_VOL

+  bool _endMarker;

+  #endif

+

+  bool _useAlign;

+

+  HRESULT WriteSignature();

+  #ifdef _7Z_VOL

+  HRESULT WriteFinishSignature();

+  #endif

+  HRESULT WriteStartHeader(const CStartHeader &h);

+  #ifdef _7Z_VOL

+  HRESULT WriteFinishHeader(const CFinishHeader &h);

+  #endif

+  CMyComPtr<IOutStream> Stream;

+public:

+

+  COutArchive() { _outByte.Create(1 << 16); }

+  CMyComPtr<ISequentialOutStream> SeqStream;

+  HRESULT Create(ISequentialOutStream *stream, bool endMarker);

+  void Close();

+  HRESULT SkipPrefixArchiveHeader();

+  HRESULT WriteDatabase(

+      DECL_EXTERNAL_CODECS_LOC_VARS

+      const CArchiveDatabaseOut &db,

+      const CCompressionMethodMode *options,

+      const CHeaderOptions &headerOptions);

+

+  #ifdef _7Z_VOL

+  static UInt32 GetVolHeadersSize(UInt64 dataSize, int nameLength = 0, bool props = false);

+  static UInt64 GetVolPureSize(UInt64 volSize, int nameLength = 0, bool props = false);

+  #endif

+

+};

+

+}}

+

+#endif