seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/IDecl.h

@@ -5,10 +5,23 @@
 
 #include "../Common/MyUnknown.h"
 
+#define k_7zip_GUID_Data1 0x23170F69
+#define k_7zip_GUID_Data2 0x40C1
+
+#define k_7zip_GUID_Data3_Common  0x278A
+
+#define k_7zip_GUID_Data3_Decoder 0x2790
+#define k_7zip_GUID_Data3_Encoder 0x2791
+#define k_7zip_GUID_Data3_Hasher  0x2792
+
+
 #define DECL_INTERFACE_SUB(i, base, groupId, subId) \
-DEFINE_GUID(IID_ ## i, \
-0x23170F69, 0x40C1, 0x278A, 0, 0, 0, (groupId), 0, (subId), 0, 0); \
-struct i: public base
+  DEFINE_GUID(IID_ ## i, \
+    k_7zip_GUID_Data1, \
+    k_7zip_GUID_Data2, \
+    k_7zip_GUID_Data3_Common, \
+    0, 0, 0, (groupId), 0, (subId), 0, 0); \
+  struct i: public base
 
 #define DECL_INTERFACE(i, groupId, subId) DECL_INTERFACE_SUB(i, IUnknown, groupId, subId)
 

data/ext/p7zip/CPP/7zip/IPassword.h

@@ -3,8 +3,8 @@
 #ifndef __IPASSWORD_H
 #define __IPASSWORD_H
 
+#include "../Common/MyTypes.h"
 #include "../Common/MyUnknown.h"
-#include "../Common/Types.h"
 
 #include "IDecl.h"
 
@@ -21,4 +21,3 @@ PASSWORD_INTERFACE(ICryptoGetTextPassword2, 0x11)
 };
 
 #endif
-

data/ext/p7zip/CPP/7zip/IProgress.h

@@ -1,10 +1,9 @@
-// Interface/IProgress.h
+// IProgress.h
 
 #ifndef __IPROGRESS_H
 #define __IPROGRESS_H
 
-#include "../Common/MyUnknown.h"
-#include "../Common/Types.h"
+#include "../Common/MyTypes.h"
 
 #include "IDecl.h"
 
@@ -17,17 +16,4 @@ DECL_INTERFACE(IProgress, 0, 5)
   INTERFACE_IProgress(PURE)
 };
 
-/*
-// {23170F69-40C1-278A-0000-000000050002}
-DEFINE_GUID(IID_IProgress2,
-0x23170F69, 0x40C1, 0x278A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x02);
-MIDL_INTERFACE("23170F69-40C1-278A-0000-000000050002")
-IProgress2: public IUnknown
-{
-public:
-  STDMETHOD(SetTotal)(const UInt64 *total) PURE;
-  STDMETHOD(SetCompleted)(const UInt64 *completeValue) PURE;
-};
-*/
-
 #endif

data/ext/p7zip/CPP/7zip/IStream.h

@@ -3,8 +3,8 @@
 #ifndef __ISTREAM_H
 #define __ISTREAM_H
 
-#include "../Common/MyUnknown.h"
-#include "../Common/Types.h"
+#include "../Common/MyTypes.h"
+#include "../Common/MyWindows.h"
 
 #include "IDecl.h"
 
@@ -14,26 +14,71 @@
 STREAM_INTERFACE(ISequentialInStream, 0x01)
 {
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) PURE;
+  
   /*
-  Out: if size != 0, return_value = S_OK and (*processedSize == 0),
-    then there are no more bytes in stream.
-  if (size > 0) && there are bytes in stream,
-  this function must read at least 1 byte.
-  This function is allowed to read less than number of remaining bytes in stream.
-  You must call Read function in loop, if you need exact amount of data
+  The requirement for caller: (processedSize != NULL).
+  The callee can allow (processedSize == NULL) for compatibility reasons.
+    
+  if (size == 0), this function returns S_OK and (*processedSize) is set to 0.
+
+  if (size != 0)
+  {
+    Partial read is allowed: (*processedSize <= avail_size && *processedSize <= size),
+      where (avail_size) is the size of remaining bytes in stream.
+    If (avail_size != 0), this function must read at least 1 byte: (*processedSize > 0).
+    You must call Read() in loop, if you need to read exact amount of data.
+  }
+
+  If seek pointer before Read() call was changed to position past the end of stream:
+    if (seek_pointer >= stream_size), this function returns S_OK and (*processedSize) is set to 0.
+  
+  ERROR CASES:
+    If the function returns error code, then (*processedSize) is size of
+    data written to (data) buffer (it can be data before error or data with errors).
+    The recommended way for callee to work with reading errors:
+      1) write part of data before error to (data) buffer and return S_OK.
+      2) return error code for further calls of Read().
   */
 };
 
 STREAM_INTERFACE(ISequentialOutStream, 0x02)
 {
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) PURE;
+  
   /*
-  if (size > 0) this function must write at least 1 byte.
-  This function is allowed to write less than "size".
-  You must call Write function in loop, if you need to write exact amount of data
+  The requirement for caller: (processedSize != NULL).
+  The callee can allow (processedSize == NULL) for compatibility reasons.
+
+  if (size != 0)
+  {
+    Partial write is allowed: (*processedSize <= size),
+    but this function must write at least 1 byte: (*processedSize > 0).
+    You must call Write() in loop, if you need to write exact amount of data.
+  }
+
+  ERROR CASES:
+    If the function returns error code, then (*processedSize) is size of
+    data written from (data) buffer.
   */
 };
 
+#ifdef __HRESULT_FROM_WIN32
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#else
+#define HRESULT_WIN32_ERROR_NEGATIVE_SEEK   HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK)
+#endif
+
+/*  Seek() Function
+  If you seek before the beginning of the stream, Seek() function returns error code:
+      Recommended error code is __HRESULT_FROM_WIN32(ERROR_NEGATIVE_SEEK).
+      or STG_E_INVALIDFUNCTION
+      
+  It is allowed to seek past the end of the stream.
+
+
+  if Seek() returns error, then the value of *newPosition is undefined.
+*/
+
 STREAM_INTERFACE_SUB(IInStream, ISequentialInStream, 0x03)
 {
   STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition) PURE;
@@ -50,9 +95,33 @@ STREAM_INTERFACE(IStreamGetSize, 0x06)
   STDMETHOD(GetSize)(UInt64 *size) PURE;
 };
 
-STREAM_INTERFACE(IOutStreamFlush, 0x07)
+STREAM_INTERFACE(IOutStreamFinish, 0x07)
+{
+  STDMETHOD(OutStreamFinish)() PURE;
+};
+
+
+STREAM_INTERFACE(IStreamGetProps, 0x08)
+{
+  STDMETHOD(GetProps)(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib) PURE;
+};
+
+struct CStreamFileProps
+{
+  UInt64 Size;
+  UInt64 VolID;
+  UInt64 FileID_Low;
+  UInt64 FileID_High;
+  UInt32 NumLinks;
+  UInt32 Attrib;
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+};
+
+STREAM_INTERFACE(IStreamGetProps2, 0x09)
 {
-  STDMETHOD(Flush)() PURE;
+  STDMETHOD(GetProps2)(CStreamFileProps *props) PURE;
 };
 
 #endif

data/ext/p7zip/CPP/7zip/MyVersion.h

@@ -1,11 +1,2 @@
-#define MY_VER_MAJOR 9
-#define MY_VER_MINOR 20
-#define MY_VER_BUILD 0
-#define MY_VERSION "9.20"
-#define MY_7ZIP_VERSION "7-Zip 9.20"
-#define MY_DATE "2010-11-18"
-#define MY_COPYRIGHT "Copyright (c) 1999-2010 Igor Pavlov"
-#define MY_VERSION_COPYRIGHT_DATE MY_VERSION "  " MY_COPYRIGHT "  " MY_DATE
-
-#define P7ZIP_VERSION "9.20"
-
+#define USE_COPYRIGHT_CR
+#include "../../C/7zVersion.h"

data/ext/p7zip/CPP/7zip/PropID.h

@@ -1,13 +1,15 @@
 // PropID.h
 
-#ifndef __7ZIP_PROPID_H
-#define __7ZIP_PROPID_H
+#ifndef __7ZIP_PROP_ID_H
+#define __7ZIP_PROP_ID_H
+
+#include "../Common/MyTypes.h"
 
 enum
 {
   kpidNoProperty = 0,
-  kpidMainSubfile = 1,
-  kpidHandlerItemIndex = 2,
+  kpidMainSubfile,
+  kpidHandlerItemIndex,
   kpidPath,
   kpidName,
   kpidExtension,
@@ -59,18 +61,67 @@ enum
   kpidCreatorApp,
   kpidSectorSize,
   kpidPosixAttrib,
-  kpidLink,
+  kpidSymLink,
   kpidError,
-
-  kpidTotalSize = 0x1100,
+  kpidTotalSize,
   kpidFreeSpace,
   kpidClusterSize,
   kpidVolumeName,
-
-  kpidLocalName = 0x1200,
+  kpidLocalName,
   kpidProvider,
+  kpidNtSecure,
+  kpidIsAltStream,
+  kpidIsAux,
+  kpidIsDeleted,
+  kpidIsTree,
+  kpidSha1,
+  kpidSha256,
+  kpidErrorType,
+  kpidNumErrors,
+  kpidErrorFlags,
+  kpidWarningFlags,
+  kpidWarning,
+  kpidNumStreams,
+  kpidNumAltStreams,
+  kpidAltStreamsSize,
+  kpidVirtualSize,
+  kpidUnpackSize,
+  kpidTotalPhySize,
+  kpidVolumeIndex,
+  kpidSubType,
+  kpidShortComment,
+  kpidCodePage,
+  kpidIsNotArcType,
+  kpidPhySizeCantBeDetected,
+  kpidZerosTailIsAllowed,
+  kpidTailSize,
+  kpidEmbeddedStubSize,
+  kpidNtReparse,
+  kpidHardLink,
+  kpidINode,
+  kpidStreamId,
+  kpidReadOnly,
+  kpidOutName,
+  kpidCopyLink,
+
+  kpid_NUM_DEFINED,
 
   kpidUserDefined = 0x10000
 };
 
+extern const Byte k7z_PROPID_To_VARTYPE[kpid_NUM_DEFINED]; // VARTYPE
+
+const UInt32 kpv_ErrorFlags_IsNotArc              = 1 << 0;
+const UInt32 kpv_ErrorFlags_HeadersError          = 1 << 1;
+const UInt32 kpv_ErrorFlags_EncryptedHeadersError = 1 << 2;
+const UInt32 kpv_ErrorFlags_UnavailableStart      = 1 << 3;
+const UInt32 kpv_ErrorFlags_UnconfirmedStart      = 1 << 4;
+const UInt32 kpv_ErrorFlags_UnexpectedEnd         = 1 << 5;
+const UInt32 kpv_ErrorFlags_DataAfterEnd          = 1 << 6;
+const UInt32 kpv_ErrorFlags_UnsupportedMethod     = 1 << 7;
+const UInt32 kpv_ErrorFlags_UnsupportedFeature    = 1 << 8;
+const UInt32 kpv_ErrorFlags_DataError             = 1 << 9;
+const UInt32 kpv_ErrorFlags_CrcError              = 1 << 10;
+// const UInt32 kpv_ErrorFlags_Unsupported           = 1 << 11;
+
 #endif

data/ext/p7zip/CPP/Common/C_FileIO.cpp

@@ -1,9 +1,13 @@
-// Common/C_FileIO.h
+// Common/C_FileIO.cpp
 
 #include "C_FileIO.h"
 
 #include <fcntl.h>
+#ifdef _WIN32
+#include <io.h>
+#else
 #include <unistd.h>
+#endif
 
 namespace NC {
 namespace NFile {

data/ext/p7zip/CPP/Common/C_FileIO.h

@@ -6,9 +6,15 @@
 #include <stdio.h>
 #include <sys/types.h>
 
-#include "Types.h"
+#include "MyTypes.h"
 #include "MyWindows.h"
 
+#ifdef _WIN32
+#ifdef _MSC_VER
+typedef size_t ssize_t;
+#endif
+#endif
+
 namespace NC {
 namespace NFile {
 namespace NIO {

data/ext/p7zip/CPP/Common/CommandLineParser.cpp

@@ -4,6 +4,20 @@
 
 #include "CommandLineParser.h"
 
+static bool IsString1PrefixedByString2_NoCase(const wchar_t *u, const char *a)
+{
+  for (;;)
+  {
+    char c = *a;
+    if (c == 0)
+      return true;
+    if ((unsigned char)MyCharLower_Ascii(c) != MyCharLower_Ascii(*u))
+      return false;
+    a++;
+    u++;
+  }
+}
+
 namespace NCommandLineParser {
 
 #ifdef _WIN32
@@ -12,13 +26,13 @@ bool SplitCommandLine(const UString &src, UString &dest1, UString &dest2)
   dest1.Empty();
   dest2.Empty();
   bool quoteMode = false;
-  int i;
-  for (i = 0; i < src.Length(); i++)
+  unsigned i;
+  for (i = 0; i < src.Len(); i++)
   {
     wchar_t c = src[i];
-    if (c == L' ' && !quoteMode)
+    if ((c == L' ' || c == L'\t') && !quoteMode)
     {
-      dest2 = src.Mid(i + 1);
+      dest2 = src.Ptr(i + 1);
       return i != 0;
     }
     if (c == L'\"')
@@ -46,21 +60,18 @@ void SplitCommandLine(const UString &s, UStringVector &parts)
 }
 #endif
 
-static const wchar_t kSwitchID1 = '-';
-// static const wchar_t kSwitchID2 = '/';
+static const char *kStopSwitchParsing = "--";
 
-static const wchar_t kSwitchMinus = '-';
-static const wchar_t *kStopSwitchParsing = L"--";
-
-static bool IsItSwitchChar(wchar_t c)
+static bool inline IsItSwitchChar(wchar_t c)
 {
-  return (c == kSwitchID1 /*|| c == kSwitchID2 */);
+  return (c == '-');
 }
 
-CParser::CParser(int numSwitches):
-  _numSwitches(numSwitches)
+CParser::CParser(unsigned numSwitches):
+  _numSwitches(numSwitches),
+  _switches(0)
 {
-  _switches = new CSwitchResult[_numSwitches];
+  _switches = new CSwitchResult[numSwitches];
 }
 
 CParser::~CParser()
@@ -68,163 +79,126 @@ CParser::~CParser()
   delete []_switches;
 }
 
-void CParser::ParseStrings(const CSwitchForm *switchForms,
-  const UStringVector &commandStrings)
-{
-  int numCommandStrings = commandStrings.Size();
-  bool stopSwitch = false;
-  for (int i = 0; i < numCommandStrings; i++)
-  {
-    const UString &s = commandStrings[i];
-    if (stopSwitch)
-      NonSwitchStrings.Add(s);
-    else
-      if (s == kStopSwitchParsing)
-        stopSwitch = true;
-      else
-        if (!ParseString(s, switchForms))
-          NonSwitchStrings.Add(s);
-  }
-}
 
-// if string contains switch then function updates switch structures
-// out: (string is a switch)
+// if (s) contains switch then function updates switch structures
+// out: true, if (s) is a switch
 bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
 {
-  int len = s.Length();
-  if (len == 0)
-    return false;
-  int pos = 0;
-  if (!IsItSwitchChar(s[pos]))
+  if (s.IsEmpty() || !IsItSwitchChar(s[0]))
     return false;
-  while (pos < len)
+
+  unsigned pos = 1;
+  unsigned switchIndex = 0;
+  int maxLen = -1;
+  
+  for (unsigned i = 0; i < _numSwitches; i++)
   {
-    if (IsItSwitchChar(s[pos]))
-      pos++;
-    const int kNoLen = -1;
-    int matchedSwitchIndex = 0; // GCC Warning
-    int maxLen = kNoLen;
-    for (int switchIndex = 0; switchIndex < _numSwitches; switchIndex++)
+    const char *key = switchForms[i].Key;
+    unsigned switchLen = MyStringLen(key);
+    if ((int)switchLen <= maxLen || pos + switchLen > s.Len())
+      continue;
+    if (IsString1PrefixedByString2_NoCase((const wchar_t *)s + pos, key))
     {
-      int switchLen = MyStringLen(switchForms[switchIndex].IDString);
-      if (switchLen <= maxLen || pos + switchLen > len)
-        continue;
+      switchIndex = i;
+      maxLen = switchLen;
+    }
+  }
+
+  if (maxLen < 0)
+  {
+    ErrorMessage = "Unknown switch:";
+    return false;
+  }
 
-      UString temp = s + pos;
-      temp = temp.Left(switchLen);
-      if (temp.CompareNoCase(switchForms[switchIndex].IDString) == 0)
-      // if (_strnicmp(switchForms[switchIndex].IDString, LPCSTR(s) + pos, switchLen) == 0)
+  pos += maxLen;
+  
+  CSwitchResult &sw = _switches[switchIndex];
+  const CSwitchForm &form = switchForms[switchIndex];
+  
+  if (!form.Multi && sw.ThereIs)
+  {
+    ErrorMessage = "Multiple instances for switch:";
+    return false;
+  }
+
+  sw.ThereIs = true;
+
+  int rem = s.Len() - pos;
+  if (rem < form.MinLen)
+  {
+    ErrorMessage = "Too short switch:";
+    return false;
+  }
+  
+  sw.WithMinus = false;
+  sw.PostCharIndex = -1;
+  
+  switch (form.Type)
+  {
+    case NSwitchType::kMinus:
+      if (rem == 1)
       {
-        matchedSwitchIndex = switchIndex;
-        maxLen = switchLen;
+        sw.WithMinus = (s[pos] == '-');
+        if (sw.WithMinus)
+          return true;
+        ErrorMessage = "Incorrect switch postfix:";
+        return false;
       }
-    }
-    if (maxLen == kNoLen)
-      throw "maxLen == kNoLen";
-    CSwitchResult &matchedSwitch = _switches[matchedSwitchIndex];
-    const CSwitchForm &switchForm = switchForms[matchedSwitchIndex];
-    if ((!switchForm.Multi) && matchedSwitch.ThereIs)
-      throw "switch must be single";
-    matchedSwitch.ThereIs = true;
-    pos += maxLen;
-    int tailSize = len - pos;
-    NSwitchType::EEnum type = switchForm.Type;
-    switch(type)
-    {
-      case NSwitchType::kPostMinus:
-        {
-          if (tailSize == 0)
-            matchedSwitch.WithMinus = false;
-          else
-          {
-            matchedSwitch.WithMinus = (s[pos] == kSwitchMinus);
-            if (matchedSwitch.WithMinus)
-              pos++;
-          }
-          break;
-        }
-      case NSwitchType::kPostChar:
-        {
-          if (tailSize < switchForm.MinLen)
-            throw "switch is not full";
-          UString set = switchForm.PostCharSet;
-          const int kEmptyCharValue = -1;
-          if (tailSize == 0)
-            matchedSwitch.PostCharIndex = kEmptyCharValue;
-          else
-          {
-            int index = set.Find(s[pos]);
-            if (index < 0)
-              matchedSwitch.PostCharIndex =  kEmptyCharValue;
-            else
-            {
-              matchedSwitch.PostCharIndex = index;
-              pos++;
-            }
-          }
-          break;
-        }
-      case NSwitchType::kLimitedPostString:
-      case NSwitchType::kUnLimitedPostString:
+      break;
+      
+    case NSwitchType::kChar:
+      if (rem == 1)
+      {
+        wchar_t c = s[pos];
+        if (c <= 0x7F)
         {
-          int minLen = switchForm.MinLen;
-          if (tailSize < minLen)
-            throw "switch is not full";
-          if (type == NSwitchType::kUnLimitedPostString)
-          {
-            matchedSwitch.PostStrings.Add(s.Mid(pos));
+          sw.PostCharIndex = FindCharPosInString(form.PostCharSet, (char)c);
+          if (sw.PostCharIndex >= 0)
             return true;
-          }
-          int maxLen = switchForm.MaxLen;
-          UString stringSwitch = s.Mid(pos, minLen);
-          pos += minLen;
-          for (int i = minLen; i < maxLen && pos < len; i++, pos++)
-          {
-            wchar_t c = s[pos];
-            if (IsItSwitchChar(c))
-              break;
-            stringSwitch += c;
-          }
-          matchedSwitch.PostStrings.Add(stringSwitch);
-          break;
         }
-      case NSwitchType::kSimple:
-          break;
-    }
+        ErrorMessage = "Incorrect switch postfix:";
+        return false;
+      }
+      break;
+      
+    case NSwitchType::kString:
+      sw.PostStrings.Add((const wchar_t *)s + pos);
+      return true;
   }
-  return true;
-}
 
-const CSwitchResult& CParser::operator[](size_t index) const
-{
-  return _switches[index];
+  if (pos != s.Len())
+  {
+    ErrorMessage = "Too long switch:";
+    return false;
+  }
+  return true;
 }
 
-/////////////////////////////////
-// Command parsing procedures
-
-int ParseCommand(int numCommandForms, const CCommandForm *commandForms,
-    const UString &commandString, UString &postString)
+bool CParser::ParseStrings(const CSwitchForm *switchForms, const UStringVector &commandStrings)
 {
-  for (int i = 0; i < numCommandForms; i++)
+  ErrorLine.Empty();
+  bool stopSwitch = false;
+  FOR_VECTOR (i, commandStrings)
   {
-    const UString id = commandForms[i].IDString;
-    if (commandForms[i].PostStringMode)
+    const UString &s = commandStrings[i];
+    if (!stopSwitch)
     {
-      if (commandString.Find(id) == 0)
+      if (s.IsEqualTo(kStopSwitchParsing))
       {
-        postString = commandString.Mid(id.Length());
-        return i;
+        stopSwitch = true;
+        continue;
       }
-    }
-    else
-      if (commandString == id)
+      if (!s.IsEmpty() && IsItSwitchChar(s[0]))
       {
-        postString.Empty();
-        return i;
+        if (ParseString(s, switchForms))
+          continue;
+        ErrorLine = s;
+        return false;
       }
+    }
+    NonSwitchStrings.Add(s);
   }
-  return -1;
+  return true;
 }
-   
+
 }