react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/Archive/IArchive.h

@@ -0,0 +1,754 @@
+// IArchive.h
+
+#ifndef ZIP7_INC_IARCHIVE_H
+#define ZIP7_INC_IARCHIVE_H
+
+#include "../IProgress.h"
+#include "../IStream.h"
+#include "../PropID.h"
+
+Z7_PURE_INTERFACES_BEGIN
+
+
+#define Z7_IFACE_CONSTR_ARCHIVE_SUB(i, base, n) \
+  Z7_DECL_IFACE_7ZIP_SUB(i, base, 6, n) \
+  { Z7_IFACE_COM7_PURE(i) };
+
+#define Z7_IFACE_CONSTR_ARCHIVE(i, n) \
+  Z7_IFACE_CONSTR_ARCHIVE_SUB(i, IUnknown, n)
+
+/*
+How the function in 7-Zip returns object for output parameter via pointer
+
+1) The caller sets the value of variable before function call:
+  PROPVARIANT  :  vt = VT_EMPTY
+  BSTR         :  NULL
+  IUnknown* and derived interfaces  :  NULL
+  another scalar types  :  any non-initialized value is allowed
+
+2) The callee in current 7-Zip code now can free input object for output parameter:
+  PROPVARIANT   : the callee calls VariantClear(propvaiant_ptr) for input
+                  value stored in variable
+  another types : the callee ignores stored value.
+
+3) The callee writes new value to variable for output parameter and
+  returns execution to caller.
+
+4) The caller must free or release object returned by the callee:
+  PROPVARIANT   : VariantClear(&propvaiant)
+  BSTR          : SysFreeString(bstr)
+  IUnknown* and derived interfaces  :  if (ptr) ptr->Relase()
+*/
+
+
+namespace NFileTimeType
+{
+  enum EEnum
+  {
+    kNotDefined = -1,
+    kWindows = 0,
+    kUnix,
+    kDOS,
+    k1ns
+  };
+}
+
+namespace NArcInfoFlags
+{
+  const UInt32 kKeepName        = 1 << 0;  // keep name of file in archive name
+  const UInt32 kAltStreams      = 1 << 1;  // the handler supports alt streams
+  const UInt32 kNtSecure        = 1 << 2;  // the handler supports NT security
+  const UInt32 kFindSignature   = 1 << 3;  // the handler can find start of archive
+  const UInt32 kMultiSignature  = 1 << 4;  // there are several signatures
+  const UInt32 kUseGlobalOffset = 1 << 5;  // the seek position of stream must be set as global offset
+  const UInt32 kStartOpen       = 1 << 6;  // call handler for each start position
+  const UInt32 kPureStartOpen   = 1 << 7;  // call handler only for start of file
+  const UInt32 kBackwardOpen    = 1 << 8;  // archive can be open backward
+  const UInt32 kPreArc          = 1 << 9;  // such archive can be stored before real archive (like SFX stub)
+  const UInt32 kSymLinks        = 1 << 10; // the handler supports symbolic links
+  const UInt32 kHardLinks       = 1 << 11; // the handler supports hard links
+  const UInt32 kByExtOnlyOpen   = 1 << 12; // call handler only if file extension matches
+  const UInt32 kHashHandler     = 1 << 13; // the handler contains the hashes (checksums)
+  const UInt32 kCTime           = 1 << 14;
+  const UInt32 kCTime_Default   = 1 << 15;
+  const UInt32 kATime           = 1 << 16;
+  const UInt32 kATime_Default   = 1 << 17;
+  const UInt32 kMTime           = 1 << 18;
+  const UInt32 kMTime_Default   = 1 << 19;
+  // const UInt32 kTTime_Reserved         = 1 << 20;
+  // const UInt32 kTTime_Reserved_Default = 1 << 21;
+}
+
+namespace NArcInfoTimeFlags
+{
+  const unsigned kTime_Prec_Mask_bit_index = 0;
+  const unsigned kTime_Prec_Mask_num_bits = 26;
+
+  const unsigned kTime_Prec_Default_bit_index = 27;
+  const unsigned kTime_Prec_Default_num_bits = 5;
+}
+
+#define TIME_PREC_TO_ARC_FLAGS_MASK(v) \
+  ((UInt32)1 << (NArcInfoTimeFlags::kTime_Prec_Mask_bit_index + (v)))
+
+#define TIME_PREC_TO_ARC_FLAGS_TIME_DEFAULT(v) \
+  ((UInt32)(v) << NArcInfoTimeFlags::kTime_Prec_Default_bit_index)
+
+namespace NArchive
+{
+  namespace NHandlerPropID
+  {
+    enum
+    {
+      kName = 0,        // VT_BSTR
+      kClassID,         // binary GUID in VT_BSTR
+      kExtension,       // VT_BSTR
+      kAddExtension,    // VT_BSTR
+      kUpdate,          // VT_BOOL
+      kKeepName,        // VT_BOOL
+      kSignature,       // binary in VT_BSTR
+      kMultiSignature,  // binary in VT_BSTR
+      kSignatureOffset, // VT_UI4
+      kAltStreams,      // VT_BOOL
+      kNtSecure,        // VT_BOOL
+      kFlags,           // VT_UI4
+      kTimeFlags        // VT_UI4
+    };
+  }
+
+  namespace NExtract
+  {
+    namespace NAskMode
+    {
+      enum
+      {
+        kExtract = 0,
+        kTest,
+        kSkip,
+        kReadExternal
+      };
+    }
+  
+    namespace NOperationResult
+    {
+      enum
+      {
+        kOK = 0,
+        kUnsupportedMethod,
+        kDataError,
+        kCRCError,
+        kUnavailable,
+        kUnexpectedEnd,
+        kDataAfterEnd,
+        kIsNotArc,
+        kHeadersError,
+        kWrongPassword
+        // , kMemError
+      };
+    }
+  }
+
+  namespace NEventIndexType
+  {
+    enum
+    {
+      kNoIndex = 0,
+      kInArcIndex,
+      kBlockIndex,
+      kOutArcIndex
+      // kArcProp
+    };
+  }
+  
+  namespace NUpdate
+  {
+    namespace NOperationResult
+    {
+      enum
+      {
+        kOK = 0
+        // kError = 1,
+        // kError_FileChanged
+      };
+    }
+  }
+}
+
+#define Z7_IFACEM_IArchiveOpenCallback(x) \
+  x(SetTotal(const UInt64 *files, const UInt64 *bytes)) \
+  x(SetCompleted(const UInt64 *files, const UInt64 *bytes)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenCallback, 0x10)
+
+/*
+IArchiveExtractCallback::
+
+7-Zip doesn't call IArchiveExtractCallback functions
+  GetStream()
+  PrepareOperation()
+  SetOperationResult()
+from different threads simultaneously.
+But 7-Zip can call functions for IProgress or ICompressProgressInfo functions
+from another threads simultaneously with calls for IArchiveExtractCallback interface.
+
+IArchiveExtractCallback::GetStream()
+  UInt32 index - index of item in Archive
+  Int32 askExtractMode  (Extract::NAskMode)
+    if (askMode != NExtract::NAskMode::kExtract)
+    {
+      then the callee doesn't write data to stream: (*outStream == NULL)
+    }
+  
+  Out:
+      (*outStream == NULL) - for directories
+      (*outStream == NULL) - if link (hard link or symbolic link) was created
+      if (*outStream == NULL && askMode == NExtract::NAskMode::kExtract)
+      {
+        then the caller must skip extracting of that file.
+      }
+
+  returns:
+    S_OK     : OK
+    S_FALSE  : data error (for decoders)
+
+if (IProgress::SetTotal() was called)
+{
+  IProgress::SetCompleted(completeValue) uses
+    packSize   - for some stream formats (xz, gz, bz2, lzma, z, ppmd).
+    unpackSize - for another formats.
+}
+else
+{
+  IProgress::SetCompleted(completeValue) uses packSize.
+}
+
+SetOperationResult()
+  7-Zip calls SetOperationResult at the end of extracting,
+  so the callee can close the file, set attributes, timestamps and security information.
+
+  Int32 opRes (NExtract::NOperationResult)
+*/
+
+// INTERFACE_IProgress(x)
+
+#define Z7_IFACEM_IArchiveExtractCallback(x) \
+  x(GetStream(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode)) \
+  x(PrepareOperation(Int32 askExtractMode)) \
+  x(SetOperationResult(Int32 opRes)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveExtractCallback, IProgress, 0x20)
+
+
+
+/*
+v23:
+IArchiveExtractCallbackMessage2 can be requested from IArchiveExtractCallback object
+  by Extract() or UpdateItems() functions to report about extracting errors
+ReportExtractResult()
+  UInt32 indexType (NEventIndexType)
+  UInt32 index
+  Int32 opRes (NExtract::NOperationResult)
+*/
+/*
+before v23:
+#define Z7_IFACEM_IArchiveExtractCallbackMessage(x) \
+  x(ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveExtractCallbackMessage, IProgress, 0x21)
+*/
+#define Z7_IFACEM_IArchiveExtractCallbackMessage2(x) \
+  x(ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveExtractCallbackMessage2, 0x22)
+
+#define Z7_IFACEM_IArchiveOpenVolumeCallback(x) \
+  x(GetProperty(PROPID propID, PROPVARIANT *value)) \
+  x(GetStream(const wchar_t *name, IInStream **inStream))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenVolumeCallback, 0x30)
+
+
+#define Z7_IFACEM_IInArchiveGetStream(x) \
+  x(GetStream(UInt32 index, ISequentialInStream **stream))
+Z7_IFACE_CONSTR_ARCHIVE(IInArchiveGetStream, 0x40)
+
+#define Z7_IFACEM_IArchiveOpenSetSubArchiveName(x) \
+  x(SetSubArchiveName(const wchar_t *name))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenSetSubArchiveName, 0x50)
+
+
+/*
+IInArchive::Open
+    stream
+      if (kUseGlobalOffset), stream current position can be non 0.
+      if (!kUseGlobalOffset), stream current position is 0.
+    if (maxCheckStartPosition == NULL), the handler can try to search archive start in stream
+    if (*maxCheckStartPosition == 0), the handler must check only current position as archive start
+
+IInArchive::Extract:
+  indices must be sorted
+  numItems = (UInt32)(Int32)-1 = 0xFFFFFFFF means "all files"
+  testMode != 0 means "test files without writing to outStream"
+
+IInArchive::GetArchiveProperty:
+  kpidOffset  - start offset of archive.
+      VT_EMPTY : means offset = 0.
+      VT_UI4, VT_UI8, VT_I8 : result offset; negative values is allowed
+  kpidPhySize - size of archive. VT_EMPTY means unknown size.
+    kpidPhySize is allowed to be larger than file size. In that case it must show
+    supposed size.
+
+  kpidIsDeleted:
+  kpidIsAltStream:
+  kpidIsAux:
+  kpidINode:
+    must return VARIANT_TRUE (VT_BOOL), if archive can support that property in GetProperty.
+
+
+Notes:
+  Don't call IInArchive functions for same IInArchive object from different threads simultaneously.
+  Some IInArchive handlers will work incorrectly in that case.
+*/
+
+#if defined(_MSC_VER) && !defined(__clang__)
+  #define MY_NO_THROW_DECL_ONLY  Z7_COM7F_E
+#else
+  #define MY_NO_THROW_DECL_ONLY
+#endif
+
+#define Z7_IFACEM_IInArchive(x) \
+  x(Open(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *openCallback)) \
+  x(Close()) \
+  x(GetNumberOfItems(UInt32 *numItems)) \
+  x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+  x(Extract(const UInt32 *indices, UInt32 numItems, Int32 testMode, IArchiveExtractCallback *extractCallback)) \
+  x(GetArchiveProperty(PROPID propID, PROPVARIANT *value)) \
+  x(GetNumberOfProperties(UInt32 *numProps)) \
+  x(GetPropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+  x(GetNumberOfArchiveProperties(UInt32 *numProps)) \
+  x(GetArchivePropertyInfo(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IInArchive, 0x60)
+
+namespace NParentType
+{
+  enum
+  {
+    kDir = 0,
+    kAltStream
+  };
+}
+
+namespace NPropDataType
+{
+  const UInt32 kMask_ZeroEnd   = 1 << 4;
+  // const UInt32 kMask_BigEndian = 1 << 5;
+  const UInt32 kMask_Utf       = 1 << 6;
+  const UInt32 kMask_Utf8  = kMask_Utf | 0;
+  const UInt32 kMask_Utf16 = kMask_Utf | 1;
+  // const UInt32 kMask_Utf32 = kMask_Utf | 2;
+
+  const UInt32 kNotDefined = 0;
+  const UInt32 kRaw = 1;
+
+  const UInt32 kUtf8z  = kMask_Utf8  | kMask_ZeroEnd;
+  const UInt32 kUtf16z = kMask_Utf16 | kMask_ZeroEnd;
+}
+
+// UTF string (pointer to wchar_t) with zero end and little-endian.
+#define PROP_DATA_TYPE_wchar_t_PTR_Z_LE ((NPropDataType::kMask_Utf | NPropDataType::kMask_ZeroEnd) + (sizeof(wchar_t) >> 1))
+
+
+/*
+GetRawProp:
+  Result:
+    S_OK - even if property is not set
+*/
+
+#define Z7_IFACEM_IArchiveGetRawProps(x) \
+  x(GetParent(UInt32 index, UInt32 *parent, UInt32 *parentType)) \
+  x(GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)) \
+  x(GetNumRawProps(UInt32 *numProps)) \
+  x(GetRawPropInfo(UInt32 index, BSTR *name, PROPID *propID))
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetRawProps, 0x70)
+
+#define Z7_IFACEM_IArchiveGetRootProps(x) \
+  x(GetRootProp(PROPID propID, PROPVARIANT *value)) \
+  x(GetRootRawProp(PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType)) \
+ 
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetRootProps, 0x71)
+
+#define Z7_IFACEM_IArchiveOpenSeq(x) \
+  x(OpenSeq(ISequentialInStream *stream)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpenSeq, 0x61)
+
+/*
+  OpenForSize
+  Result:
+    S_FALSE - is not archive
+    ? - DATA error
+*/
+    
+/*
+const UInt32 kOpenFlags_RealPhySize = 1 << 0;
+const UInt32 kOpenFlags_NoSeek = 1 << 1;
+// const UInt32 kOpenFlags_BeforeExtract = 1 << 2;
+*/
+
+/*
+Flags:
+   0 - opens archive with IInStream, if IInStream interface is supported
+     - if phySize is not available, it doesn't try to make full parse to get phySize
+   kOpenFlags_NoSeek -  ArcOpen2 function doesn't use IInStream interface, even if it's available
+   kOpenFlags_RealPhySize - the handler will try to get PhySize, even if it requires full decompression for file
+   
+  if handler is not allowed to use IInStream and the flag kOpenFlags_RealPhySize is not specified,
+  the handler can return S_OK, but it doesn't check even Signature.
+  So next Extract can be called for that sequential stream.
+*/
+/*
+#define Z7_IFACEM_IArchiveOpen2(x) \
+  x(ArcOpen2(ISequentialInStream *stream, UInt32 flags, IArchiveOpenCallback *openCallback))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveOpen2, 0x62)
+*/
+
+// ---------- UPDATE ----------
+
+/*
+GetUpdateItemInfo outs:
+*newData  *newProps
+   0        0      - Copy data and properties from archive
+   0        1      - Copy data from archive, request new properties
+   1        0      - that combination is unused now
+   1        1      - Request new data and new properties. It can be used even for folders
+
+  indexInArchive = -1 if there is no item in archive, or if it doesn't matter.
+
+
+GetStream out:
+  Result:
+    S_OK:
+      (*inStream == NULL) - only for directories
+                          - the bug was fixed in 9.33: (*Stream == NULL) was in case of anti-file
+      (*inStream != NULL) - for any file, even for empty file or anti-file
+    S_FALSE - skip that file (don't add item to archive) - (client code can't open stream of that file by some reason)
+      (*inStream == NULL)
+
+The order of calling for hard links:
+  - GetStream()
+  - GetProperty(kpidHardLink)
+
+SetOperationResult()
+  Int32 opRes (NExtract::NOperationResult::kOK)
+*/
+
+// INTERFACE_IProgress(x)
+#define Z7_IFACEM_IArchiveUpdateCallback(x) \
+  x(GetUpdateItemInfo(UInt32 index, Int32 *newData, Int32 *newProps, UInt32 *indexInArchive)) \
+  x(GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+  x(GetStream(UInt32 index, ISequentialInStream **inStream)) \
+  x(SetOperationResult(Int32 operationResult)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveUpdateCallback, IProgress, 0x80)
+
+// INTERFACE_IArchiveUpdateCallback(x)
+#define Z7_IFACEM_IArchiveUpdateCallback2(x) \
+  x(GetVolumeSize(UInt32 index, UInt64 *size)) \
+  x(GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)) \
+
+Z7_IFACE_CONSTR_ARCHIVE_SUB(IArchiveUpdateCallback2, IArchiveUpdateCallback, 0x82)
+
+namespace NUpdateNotifyOp
+{
+  enum
+  {
+    kAdd = 0,
+    kUpdate,
+    kAnalyze,
+    kReplicate,
+    kRepack,
+    kSkip,
+    kDelete,
+    kHeader,
+    kHashRead,
+    kInFileChanged
+    // , kOpFinished
+    // , kNumDefined
+  };
+}
+
+/*
+IArchiveUpdateCallbackFile::ReportOperation
+  UInt32 indexType (NEventIndexType)
+  UInt32 index
+  UInt32 notifyOp (NUpdateNotifyOp)
+*/
+
+#define Z7_IFACEM_IArchiveUpdateCallbackFile(x) \
+  x(GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 notifyOp)) \
+  x(ReportOperation(UInt32 indexType, UInt32 index, UInt32 notifyOp)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveUpdateCallbackFile, 0x83)
+
+
+#define Z7_IFACEM_IArchiveGetDiskProperty(x) \
+  x(GetDiskProperty(UInt32 index, PROPID propID, PROPVARIANT *value)) \
+  
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveGetDiskProperty, 0x84)
+
+/*
+#define Z7_IFACEM_IArchiveUpdateCallbackArcProp(x) \
+  x(ReportProp(UInt32 indexType, UInt32 index, PROPID propID, const PROPVARIANT *value)) \
+  x(ReportRawProp(UInt32 indexType, UInt32 index, PROPID propID, const void *data, UInt32 dataSize, UInt32 propType)) \
+  x(ReportFinished(UInt32 indexType, UInt32 index, Int32 opRes)) \
+  x(DoNeedArcProp(PROPID propID, Int32 *answer)) \
+ 
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveUpdateCallbackArcProp, 0x85)
+*/
+
+/*
+UpdateItems()
+-------------
+
+  outStream: output stream. (the handler) MUST support the case when
+    Seek position in outStream is not ZERO.
+    but the caller calls with empty outStream and seek position is ZERO??
+ 
+  archives with stub:
+
+  If archive is open and the handler and (Offset > 0), then the handler
+  knows about stub size.
+  UpdateItems():
+  1) the handler MUST copy that stub to outStream
+  2) the caller MUST NOT copy the stub to outStream, if
+     "rsfx" property is set with SetProperties
+
+  the handler must support the case where
+    ISequentialOutStream *outStream
+*/
+
+
+#define Z7_IFACEM_IOutArchive(x) \
+  x(UpdateItems(ISequentialOutStream *outStream, UInt32 numItems, IArchiveUpdateCallback *updateCallback)) \
+  x(GetFileTimeType(UInt32 *type))
+
+Z7_IFACE_CONSTR_ARCHIVE(IOutArchive, 0xA0)
+
+
+/*
+ISetProperties::SetProperties()
+  PROPVARIANT values[i].vt:
+    VT_EMPTY
+    VT_BOOL
+    VT_UI4   - if 32-bit number
+    VT_UI8   - if 64-bit number
+    VT_BSTR
+*/
+
+#define Z7_IFACEM_ISetProperties(x) \
+  x(SetProperties(const wchar_t * const *names, const PROPVARIANT *values, UInt32 numProps))
+
+Z7_IFACE_CONSTR_ARCHIVE(ISetProperties, 0x03)
+
+#define Z7_IFACEM_IArchiveKeepModeForNextOpen(x) \
+  x(KeepModeForNextOpen()) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveKeepModeForNextOpen, 0x04)
+
+/* Exe handler: the handler for executable format (PE, ELF, Mach-O).
+   SFX archive: executable stub + some tail data.
+     before 9.31: exe handler didn't parse SFX archives as executable format.
+     for 9.31+: exe handler parses SFX archives as executable format, only if AllowTail(1) was called */
+
+#define Z7_IFACEM_IArchiveAllowTail(x) \
+  x(AllowTail(Int32 allowTail)) \
+
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveAllowTail, 0x05)
+
+
+namespace NRequestMemoryUseFlags
+{
+  const UInt32 k_AllowedSize_WasForced    = 1 << 0;  // (*allowedSize) was forced by -mmemx or -smemx
+  const UInt32 k_DefaultLimit_Exceeded    = 1 << 1;  // default limit of archive format was exceeded
+  const UInt32 k_MLimit_Exceeded          = 1 << 2;  // -mmemx value was exceeded
+  const UInt32 k_SLimit_Exceeded          = 1 << 3;  // -smemx value was exceeded
+  
+  const UInt32 k_NoErrorMessage           = 1 << 10; // do not show error message, and show only request
+  const UInt32 k_IsReport                 = 1 << 11; // only report is required, without user request
+  
+  const UInt32 k_SkipArc_IsExpected       = 1 << 12; // NRequestMemoryAnswerFlags::k_SkipArc flag answer is expected
+  const UInt32 k_Report_SkipArc           = 1 << 13; // report about SkipArc operation
+
+  // const UInt32 k_SkipBigFile_IsExpected   = 1 << 14; // NRequestMemoryAnswerFlags::k_SkipBigFiles flag answer is expected (unused)
+  // const UInt32 k_Report_SkipBigFile       = 1 << 15; // report about SkipFile operation (unused)
+
+  // const UInt32 k_SkipBigFiles_IsExpected  = 1 << 16; // NRequestMemoryAnswerFlags::k_SkipBigFiles flag answer is expected (unused)
+  // const UInt32 k_Report_SkipBigFiles      = 1 << 17; // report that all big files will be skipped (unused)
+}
+
+namespace NRequestMemoryAnswerFlags
+{
+  const UInt32 k_Allow          = 1 << 0;  // allow further archive extraction
+  const UInt32 k_Stop           = 1 << 1;  // for exit (and return_code == E_ABORT is used)
+  const UInt32 k_SkipArc        = 1 << 2;  // skip current archive extraction
+  // const UInt32 k_SkipBigFile    = 1 << 4;  // skip extracting of files that exceed limit (unused)
+  // const UInt32 k_SkipBigFiles   = 1 << 5;  // skip extracting of files that exceed limit (unused)
+  const UInt32 k_Limit_Exceeded  = 1 << 10;  // limit was exceeded
+}
+
+/*
+  *allowedSize is in/out:
+    in  : default allowed memory usage size or forced size, if it was changed by switch -mmemx.
+    out : value specified by user or unchanged value.
+
+  *answerFlags is in/out:
+    *answerFlags must be set by caller before calling for default action,
+
+  indexType : must be set with NEventIndexType::* constant
+          (indexType == kNoIndex), if request for whole archive.
+  index : must be set for some (indexType) types (if
+          fileIndex , if (indexType == NEventIndexType::kInArcIndex)
+          0, if       if (indexType == kNoIndex)
+  path : NULL can be used for any indexType.
+*/
+#define Z7_IFACEM_IArchiveRequestMemoryUseCallback(x) \
+  x(RequestMemoryUse(UInt32 flags, UInt32 indexType, UInt32 index, const wchar_t *path, \
+    UInt64 requiredSize, UInt64 *allowedSize, UInt32 *answerFlags))
+Z7_IFACE_CONSTR_ARCHIVE(IArchiveRequestMemoryUseCallback, 0x09)
+
+
+struct CStatProp
+{
+  const char *Name;
+  UInt32 PropID;
+  VARTYPE vt;
+};
+
+namespace NWindows {
+namespace NCOM {
+// PropVariant.cpp
+BSTR AllocBstrFromAscii(const char *s) throw();
+}}
+
+
+#define IMP_IInArchive_GetProp_Base(fn, f, k) \
+  Z7_COM7F_IMF(CHandler::fn(UInt32 *numProps)) \
+    { *numProps = Z7_ARRAY_SIZE(k); return S_OK; } \
+  Z7_COM7F_IMF(CHandler::f(UInt32 index, BSTR *name, PROPID *propID, VARTYPE *varType)) \
+    { if (index >= Z7_ARRAY_SIZE(k)) return E_INVALIDARG; \
+
+#define IMP_IInArchive_GetProp_NO_NAME(fn, f, k) \
+  IMP_IInArchive_GetProp_Base(fn, f, k) \
+    *propID = k[index]; \
+    *varType = k7z_PROPID_To_VARTYPE[(unsigned)*propID]; \
+    *name = NULL; return S_OK; } \
+
+#define IMP_IInArchive_GetProp_WITH_NAME(fn, f, k) \
+  IMP_IInArchive_GetProp_Base(fn, f, k) \
+    const CStatProp &prop = k[index]; \
+    *propID = (PROPID)prop.PropID; \
+    *varType = prop.vt; \
+    *name = NWindows::NCOM::AllocBstrFromAscii(prop.Name); return S_OK; } \
+
+
+#define IMP_IInArchive_Props \
+  IMP_IInArchive_GetProp_NO_NAME(GetNumberOfProperties, GetPropertyInfo, kProps)
+
+#define IMP_IInArchive_Props_WITH_NAME \
+  IMP_IInArchive_GetProp_WITH_NAME(GetNumberOfProperties, GetPropertyInfo, kProps)
+
+#define IMP_IInArchive_ArcProps \
+  IMP_IInArchive_GetProp_NO_NAME(GetNumberOfArchiveProperties, GetArchivePropertyInfo, kArcProps)
+
+#define IMP_IInArchive_ArcProps_WITH_NAME \
+  IMP_IInArchive_GetProp_WITH_NAME(GetNumberOfArchiveProperties, GetArchivePropertyInfo, kArcProps)
+
+#define IMP_IInArchive_ArcProps_NO_Table \
+  Z7_COM7F_IMF(CHandler::GetNumberOfArchiveProperties(UInt32 *numProps)) \
+    { *numProps = 0; return S_OK; } \
+  Z7_COM7F_IMF(CHandler::GetArchivePropertyInfo(UInt32, BSTR *, PROPID *, VARTYPE *)) \
+    { return E_NOTIMPL; } \
+
+#define IMP_IInArchive_ArcProps_NO \
+  IMP_IInArchive_ArcProps_NO_Table \
+  Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID, PROPVARIANT *value)) \
+    { value->vt = VT_EMPTY; return S_OK; }
+
+
+#define Z7_class_CHandler_final \
+        Z7_class_final(CHandler)
+
+
+#define Z7_CLASS_IMP_CHandler_IInArchive_0 \
+  Z7_CLASS_IMP_COM_1(CHandler, IInArchive)
+#define Z7_CLASS_IMP_CHandler_IInArchive_1(i1) \
+  Z7_CLASS_IMP_COM_2(CHandler, IInArchive, i1)
+#define Z7_CLASS_IMP_CHandler_IInArchive_2(i1, i2) \
+  Z7_CLASS_IMP_COM_3(CHandler, IInArchive, i1, i2)
+#define Z7_CLASS_IMP_CHandler_IInArchive_3(i1, i2, i3) \
+  Z7_CLASS_IMP_COM_4(CHandler, IInArchive, i1, i2, i3)
+#define Z7_CLASS_IMP_CHandler_IInArchive_4(i1, i2, i3, i4) \
+  Z7_CLASS_IMP_COM_5(CHandler, IInArchive, i1, i2, i3, i4)
+#define Z7_CLASS_IMP_CHandler_IInArchive_5(i1, i2, i3, i4, i5) \
+  Z7_CLASS_IMP_COM_6(CHandler, IInArchive, i1, i2, i3, i4, i5)
+
+
+
+#define k_IsArc_Res_NO   0
+#define k_IsArc_Res_YES  1
+#define k_IsArc_Res_NEED_MORE 2
+// #define k_IsArc_Res_YES_LOW_PROB 3
+
+#define API_FUNC_IsArc EXTERN_C UInt32 WINAPI
+#define API_FUNC_static_IsArc extern "C" { static UInt32 WINAPI
+
+extern "C"
+{
+  typedef HRESULT (WINAPI *Func_CreateObject)(const GUID *clsID, const GUID *iid, void **outObject);
+
+  typedef UInt32 (WINAPI *Func_IsArc)(const Byte *p, size_t size);
+  typedef HRESULT (WINAPI *Func_GetIsArc)(UInt32 formatIndex, Func_IsArc *isArc);
+
+  typedef HRESULT (WINAPI *Func_GetNumberOfFormats)(UInt32 *numFormats);
+  typedef HRESULT (WINAPI *Func_GetHandlerProperty)(PROPID propID, PROPVARIANT *value);
+  typedef HRESULT (WINAPI *Func_GetHandlerProperty2)(UInt32 index, PROPID propID, PROPVARIANT *value);
+
+  typedef HRESULT (WINAPI *Func_SetCaseSensitive)(Int32 caseSensitive);
+  typedef HRESULT (WINAPI *Func_SetLargePageMode)();
+  // typedef HRESULT (WINAPI *Func_SetClientVersion)(UInt32 version);
+
+  typedef IOutArchive * (*Func_CreateOutArchive)();
+  typedef IInArchive * (*Func_CreateInArchive)();
+}
+
+
+/*
+  if there is no time in archive, external MTime of archive
+  will be used instead of _item.Time from archive.
+  For 7-zip before 22.00 we need to return some supported value.
+  But (kpidTimeType > kDOS) is not allowed in 7-Zip before 22.00.
+  So we return highest precision value supported by old 7-Zip.
+  new 7-Zip 22.00 doesn't use that value in usual cases.
+*/
+
+
+#define DECLARE_AND_SET_CLIENT_VERSION_VAR
+#define GET_FileTimeType_NotDefined_for_GetFileTimeType \
+      NFileTimeType::kWindows
+
+/*
+extern UInt32 g_ClientVersion;
+
+#define GET_CLIENT_VERSION(major, minor)  \
+  ((UInt32)(((UInt32)(major) << 16) | (UInt32)(minor)))
+
+#define DECLARE_AND_SET_CLIENT_VERSION_VAR \
+  UInt32 g_ClientVersion = GET_CLIENT_VERSION(MY_VER_MAJOR, MY_VER_MINOR);
+
+#define GET_FileTimeType_NotDefined_for_GetFileTimeType \
+      ((UInt32)(g_ClientVersion >= GET_CLIENT_VERSION(22, 0) ? \
+        (UInt32)(Int32)NFileTimeType::kNotDefined : \
+        NFileTimeType::kWindows))
+*/
+
+Z7_PURE_INTERFACES_END
+#endif