seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -5,18 +5,20 @@
 #ifndef _WIN32
 
 #include "MyWindows.h"
-#include "Types.h"
+#include "MyTypes.h"
 #include <stdlib.h> /* FIXED <malloc.h> */
 
 static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
 static inline void FreeForBSTR(void *pv) { ::free(pv);}
 
+/* FIXME
 static UINT MyStringLen(const wchar_t *s)
 { 
   UINT i;
   for (i = 0; s[i] != '\0'; i++);
   return i;
 }
+*/
 
 BSTR SysAllocStringByteLen(LPCSTR psz, UINT len)
 {
@@ -35,6 +37,21 @@ BSTR SysAllocStringByteLen(LPCSTR psz, UINT len)
   return (BSTR)bstr;
 }
 
+BSTR WINAPI SysAllocStringLen(const OLECHAR *sz, unsigned int numChars) // FIXME - code
+{
+  UINT len = (numChars + 1) * sizeof(OLECHAR);
+  void *p = AllocateForBSTR(len + sizeof(UINT));
+  if (p == 0)
+    return 0;
+  memset(p,0,len + sizeof(UINT));
+  *(UINT *)p = numChars * sizeof(OLECHAR); // FIXED
+  void * bstr = (void *)((UINT *)p + 1);
+  if (sz) memmove(bstr, sz, numChars  * sizeof(OLECHAR)); // sz does not always have "wchar_t" alignment.
+
+  return (BSTR)bstr;
+}
+
+
 BSTR SysAllocString(const OLECHAR *sz)
 {
   if (sz == 0)

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

@@ -190,12 +190,20 @@ typedef PROPVARIANT tagVARIANT;
 typedef tagVARIANT VARIANT;
 typedef VARIANT VARIANTARG;
 
+#define MY_EXTERN_C extern "C"
+
 MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
 MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);
 
+#else
+
+#define MY_EXTERN_C extern
+
+
 #endif
 
 MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+MY_EXTERN_C BSTR SysAllocStringLen(const OLECHAR*,UINT);
 MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
 MY_EXTERN_C void SysFreeString(BSTR bstr);
 MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);

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

@@ -18,65 +18,32 @@ static bool IsSpaceChar(char c)
   return (c == ' ' || c == '\t' || c == 0x0D || c == 0x0A);
 }
 
-#define SKIP_SPACES(s, pos) while (IsSpaceChar(s[pos])) pos++;
+#define SKIP_SPACES(s) while (IsSpaceChar(*s)) s++;
 
-static bool ReadProperty(const AString &s, int &pos, CXmlProp &prop)
+int CXmlItem::FindProp(const AString &propName) const throw()
 {
-  prop.Name.Empty();
-  prop.Value.Empty();
-  for (; pos < s.Length(); pos++)
-  {
-    char c = s[pos];
-    if (!IsValidChar(c))
-      break;
-    prop.Name += c;
-  }
-  
-  if (prop.Name.IsEmpty())
-    return false;
-
-  SKIP_SPACES(s, pos);
-  if (s[pos++] != '=')
-    return false;
-
-  SKIP_SPACES(s, pos);
-  if (s[pos++] != '\"')
-    return false;
-  
-  while (pos < s.Length())
-  {
-    char c = s[pos++];
-    if (c == '\"')
-      return true;
-    prop.Value += c;
-  }
-  return false;
-}
-
-int CXmlItem::FindProperty(const AString &propName) const
-{
-  for (int i = 0; i < Props.Size(); i++)
+  FOR_VECTOR (i, Props)
     if (Props[i].Name == propName)
       return i;
   return -1;
 }
 
-AString CXmlItem::GetPropertyValue(const AString &propName) const
+AString CXmlItem::GetPropVal(const AString &propName) const
 {
-  int index = FindProperty(propName);
+  int index = FindProp(propName);
   if (index >= 0)
     return Props[index].Value;
   return AString();
 }
 
-bool CXmlItem::IsTagged(const AString &tag) const
+bool CXmlItem::IsTagged(const AString &tag) const throw()
 {
   return (IsTag && Name == tag);
 }
 
-int CXmlItem::FindSubTag(const AString &tag) const
+int CXmlItem::FindSubTag(const AString &tag) const throw()
 {
-  for (int i = 0; i < SubItems.Size(); i++)
+  FOR_VECTOR (i, SubItems)
     if (SubItems[i].IsTagged(tag))
       return i;
   return -1;
@@ -93,6 +60,17 @@ AString CXmlItem::GetSubString() const
   return AString();
 }
 
+const AString * CXmlItem::GetSubStringPtr() const throw()
+{
+  if (SubItems.Size() == 1)
+  {
+    const CXmlItem &item = SubItems[0];
+    if (!item.IsTag)
+      return &item.Name;
+  }
+  return NULL;
+}
+
 AString CXmlItem::GetSubStringForTag(const AString &tag) const
 {
   int index = FindSubTag(tag);
@@ -101,109 +79,182 @@ AString CXmlItem::GetSubStringForTag(const AString &tag) const
   return AString();
 }
 
-bool CXmlItem::ParseItems(const AString &s, int &pos, int numAllowedLevels)
+const char * CXmlItem::ParseItem(const char *s, int numAllowedLevels)
 {
-  if (numAllowedLevels == 0)
-    return false;
-  SubItems.Clear();
-  AString finishString = "</";
+  SKIP_SPACES(s);
+
+  const char *beg = s;
   for (;;)
   {
-    SKIP_SPACES(s, pos);
-
-    if (s.Mid(pos, finishString.Length()) == finishString)
-      return true;
-      
-    CXmlItem item;
-    if (!item.ParseItem(s, pos, numAllowedLevels - 1))
-      return false;
-    SubItems.Add(item);
+    char c;
+    c = *s; if (c == 0 || c == '<') break; s++;
+    c = *s; if (c == 0 || c == '<') break; s++;
   }
-}
-
-bool CXmlItem::ParseItem(const AString &s, int &pos, int numAllowedLevels)
-{
-  SKIP_SPACES(s, pos);
-
-  int pos2 = s.Find('<', pos);
-  if (pos2 < 0)
-    return false;
-  if (pos2 != pos)
+  if (*s == 0)
+    return NULL;
+  if (s != beg)
   {
     IsTag = false;
-    Name += s.Mid(pos, pos2 - pos);
-    pos = pos2;
-    return true;
+    Name.SetFrom(beg, (unsigned)(s - beg));
+    return s;
   }
+  
   IsTag = true;
 
-  pos++;
-  SKIP_SPACES(s, pos);
+  s++;
+  SKIP_SPACES(s);
 
-  for (; pos < s.Length(); pos++)
-  {
-    char c = s[pos];
-    if (!IsValidChar(c))
+  beg = s;
+  for (;; s++)
+    if (!IsValidChar(*s))
       break;
-    Name += c;
-  }
-  if (Name.IsEmpty() || pos == s.Length())
-    return false;
+  if (s == beg || *s == 0)
+    return NULL;
+  Name.SetFrom(beg, (unsigned)(s - beg));
 
-  int posTemp = pos;
   for (;;)
   {
-    SKIP_SPACES(s, pos);
-    if (s[pos] == '/')
+    beg = s;
+    SKIP_SPACES(s);
+    if (*s == '/')
     {
-      pos++;
-      // SKIP_SPACES(s, pos);
-      return (s[pos++] == '>');
+      s++;
+      // SKIP_SPACES(s);
+      if (*s != '>')
+        return NULL;
+      return s + 1;
     }
-    if (s[pos] == '>')
+    if (*s == '>')
     {
-      if (!ParseItems(s, ++pos, numAllowedLevels))
-        return false;
-      AString finishString = AString("</") + Name + AString(">");
-      if (s.Mid(pos, finishString.Length()) != finishString)
-        return false;
-      pos += finishString.Length();
-      return true;
+      s++;
+      if (numAllowedLevels == 0)
+        return NULL;
+      SubItems.Clear();
+      for (;;)
+      {
+        SKIP_SPACES(s);
+        if (s[0] == '<' && s[1] == '/')
+          break;
+        CXmlItem &item = SubItems.AddNew();
+        s = item.ParseItem(s, numAllowedLevels - 1);
+        if (!s)
+          return NULL;
+      }
+
+      s += 2;
+      unsigned len = Name.Len();
+      for (unsigned i = 0; i < len; i++)
+        if (s[i] != Name[i])
+          return NULL;
+      s += len;
+      if (s[0] != '>')
+        return NULL;
+      return s + 1;
     }
-    if (posTemp == pos)
-      return false;
-
-    CXmlProp prop;
-    if (!ReadProperty(s, pos, prop))
-      return false;
-    Props.Add(prop);
-    posTemp = pos;
+    if (beg == s)
+      return NULL;
+
+    // ReadProperty
+    CXmlProp &prop = Props.AddNew();
+
+    beg = s;
+    for (;; s++)
+    {
+      char c = *s;
+      if (!IsValidChar(c))
+        break;
+    }
+    if (s == beg)
+      return NULL;
+    prop.Name.SetFrom(beg, (unsigned)(s - beg));
+    
+    SKIP_SPACES(s);
+    if (*s != '=')
+      return NULL;
+    s++;
+    SKIP_SPACES(s);
+    if (*s != '\"')
+      return NULL;
+    s++;
+    
+    beg = s;
+    for (;;)
+    {
+      char c = *s;
+      if (c == 0)
+        return NULL;
+      if (c == '\"')
+        break;
+      s++;
+    }
+    prop.Value.SetFrom(beg, (unsigned)(s - beg));
+    s++;
   }
 }
 
-static bool SkipHeader(const AString &s, int &pos, const AString &startString, const AString &endString)
+static const char * SkipHeader(const char *s, const char *startString, const char *endString)
 {
-  SKIP_SPACES(s, pos);
-  if (s.Mid(pos, startString.Length()) == startString)
+  SKIP_SPACES(s);
+  if (IsString1PrefixedByString2(s, startString))
   {
-    pos = s.Find(endString, pos);
-    if (pos < 0)
-      return false;
-    pos += endString.Length();
-    SKIP_SPACES(s, pos);
+    s = strstr(s, endString);
+    if (!s)
+      return NULL;
+    s += strlen(endString);
   }
-  return true;
+  return s;
 }
 
-bool CXml::Parse(const AString &s)
+void CXmlItem::AppendTo(AString &s) const
 {
-  int pos = 0;
-  if (!SkipHeader(s, pos, "<?xml", "?>"))
-    return false;
-  if (!SkipHeader(s, pos, "<!DOCTYPE", ">"))
-    return false;
-  if (!Root.ParseItem(s, pos, 1000))
+  if (IsTag)
+    s += '<';
+  s += Name;
+  if (IsTag)
+  {
+    FOR_VECTOR (i, Props)
+    {
+      const CXmlProp &prop = Props[i];
+      s += ' ';
+      s += prop.Name;
+      s += '=';
+      s += '\"';
+      s += prop.Value;
+      s += '\"';
+    }
+    s += '>';
+  }
+  FOR_VECTOR (i, SubItems)
+  {
+    const CXmlItem &item = SubItems[i];
+    if (i != 0 && !SubItems[i - 1].IsTag)
+      s += ' ';
+    item.AppendTo(s);
+  }
+  if (IsTag)
+  {
+    s += '<';
+    s += '/';
+    s += Name;
+    s += '>';
+  }
+}
+
+bool CXml::Parse(const char *s)
+{
+  s = SkipHeader(s, "<?xml",    "?>"); if (!s) return false;
+  s = SkipHeader(s, "<!DOCTYPE", ">"); if (!s) return false;
+
+  s = Root.ParseItem(s, 1000);
+  if (!s || !Root.IsTag)
     return false;
-  SKIP_SPACES(s, pos);
-  return (pos == s.Length() && Root.IsTag);
+  SKIP_SPACES(s);
+  return *s == 0;
+}
+
+/*
+void CXml::AppendTo(AString &s) const
+{
+  Root.AppendTo(s);
 }
+*/

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

@@ -1,7 +1,7 @@
 // MyXml.h
 
-#ifndef __MYXML_H
-#define __MYXML_H
+#ifndef __MY_XML_H
+#define __MY_XML_H
 
 #include "MyString.h"
 
@@ -13,28 +13,31 @@ struct CXmlProp
 
 class CXmlItem
 {
-  bool ParseItems(const AString &s, int &pos, int numAllowedLevels);
-
 public:
   AString Name;
   bool IsTag;
   CObjectVector<CXmlProp> Props;
   CObjectVector<CXmlItem> SubItems;
-
-  bool ParseItem(const AString &s, int &pos, int numAllowedLevels);
   
-  bool IsTagged(const AString &tag) const;
-  int FindProperty(const AString &propName) const;
-  AString GetPropertyValue(const AString &propName) const;
+  const char * ParseItem(const char *s, int numAllowedLevels);
+
+  bool IsTagged(const AString &tag) const throw();
+  int FindProp(const AString &propName) const throw();
+  AString GetPropVal(const AString &propName) const;
   AString GetSubString() const;
-  int FindSubTag(const AString &tag) const;
+  const AString * GetSubStringPtr() const throw();
+  int FindSubTag(const AString &tag) const throw();
   AString GetSubStringForTag(const AString &tag) const;
+
+  void AppendTo(AString &s) const;
 };
 
 struct CXml
 {
   CXmlItem Root;
-  bool Parse(const AString &s);
+
+  bool Parse(const char *s);
+  // void AppendTo(AString &s) const;
 };
 
 #endif

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

@@ -0,0 +1,39 @@
+// NewHandler.cpp
+ 
+#include "StdAfx.h"
+
+#include "../../C/Alloc.h"
+
+
+#ifdef DONT_REDEFINE_NEW
+
+int g_NewHandler = 0;
+
+#else
+
+/* An overload function for the C++ new */
+void * operator new(size_t size)
+{
+  return MyAlloc(size);
+}
+
+/* An overload function for the C++ new[] */
+void * operator new[](size_t size)
+{
+    return MyAlloc(size);
+}
+
+/* An overload function for the C++ delete */
+void operator delete(void *pnt)
+{
+    MyFree(pnt);
+}
+
+/* An overload function for the C++ delete[] */
+void operator delete[](void *pnt)
+{
+    MyFree(pnt);
+}
+
+#endif
+

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

@@ -1,16 +1,69 @@
 // Common/NewHandler.h
 
-#ifndef __COMMON_NEWHANDLER_H
-#define __COMMON_NEWHANDLER_H
+#ifndef __COMMON_NEW_HANDLER_H
+#define __COMMON_NEW_HANDLER_H
+
+/*
+This file must be included before any code that uses operators "delete" or "new".
+Also you must compile and link "NewHandler.cpp", if you use MSVC 6.0.
+The operator "new" in MSVC 6.0 doesn't throw exception "bad_alloc".
+So we define another version of operator "new" that throws "CNewException" on failure.
+
+If you use compiler that throws exception in "new" operator (GCC or new version of MSVC),
+you can compile without "NewHandler.cpp". So standard exception "bad_alloc" will be used.
+
+It's still allowed to use redefined version of operator "new" from "NewHandler.cpp"
+with any compiler. 7-Zip's code can work with "bad_alloc" and "CNewException" exceptions.
+But if you use some additional code (outside of 7-Zip's code), you must check
+that redefined version of operator "new" (that throws CNewException) is not
+problem for your code.
+
+Also we declare delete(void *p) throw() that creates smaller code.
+*/
+
+#include <stddef.h>
 
 class CNewException {};
 
+#ifdef WIN32
+// We can compile my_new and my_delete with _fastcall
+/*
+void * my_new(size_t size);
+void my_delete(void *p) throw();
+// void * my_Realloc(void *p, size_t newSize, size_t oldSize);
+*/
+#endif
+
 #ifdef _WIN32
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size);
+
 void
 #ifdef _MSC_VER
 __cdecl
 #endif
 operator delete(void *p) throw();
+
+#endif
+
+/*
+#ifdef _WIN32
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size);
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw();
 #endif
+*/
 
 #endif

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

@@ -0,0 +1,14 @@
+// Common/Random.h
+
+#ifndef __COMMON_RANDOM_H
+#define __COMMON_RANDOM_H
+
+class CRandom
+{
+public:
+  void Init();
+  void Init(unsigned int seed);
+  int Generate() const;
+};
+
+#endif

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

@@ -0,0 +1,40 @@
+// Sha1Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha1.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CSha1Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  CSha1 _sha;
+  Byte mtDummy[1 << 7];
+  
+public:
+  CSha1Hasher() { Sha1_Init(&_sha); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSha1Hasher::Init() throw()
+{
+  Sha1_Init(&_sha);
+}
+
+STDMETHODIMP_(void) CSha1Hasher::Update(const void *data, UInt32 size) throw()
+{
+  Sha1_Update(&_sha, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSha1Hasher::Final(Byte *digest) throw()
+{
+  Sha1_Final(&_sha, digest);
+}
+
+REGISTER_HASHER(CSha1Hasher, 0x201, "SHA1", SHA1_DIGEST_SIZE)

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

@@ -0,0 +1,40 @@
+// Sha256Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/Sha256.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CSha256Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  CSha256 _sha;
+  Byte mtDummy[1 << 7];
+
+public:
+  CSha256Hasher() { Sha256_Init(&_sha); }
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CSha256Hasher::Init() throw()
+{
+  Sha256_Init(&_sha);
+}
+
+STDMETHODIMP_(void) CSha256Hasher::Update(const void *data, UInt32 size) throw()
+{
+  Sha256_Update(&_sha, (const Byte *)data, size);
+}
+
+STDMETHODIMP_(void) CSha256Hasher::Final(Byte *digest) throw()
+{
+  Sha256_Final(&_sha, digest);
+}
+
+REGISTER_HASHER(CSha256Hasher, 0xA, "SHA256", SHA256_DIGEST_SIZE)