seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,54 +3,115 @@
 #include "StdAfx.h"
 
 #include "Lang.h"
-#include "TextConfig.h"
+#include "StringToInt.h"
+#include "UTFConvert.h"
 
 #include "../Windows/FileIO.h"
-#include "UTFConvert.h"
-#include "Defs.h"
 
-static bool HexStringToNumber(const UString &s, UInt32 &value)
+void CLang::Clear() throw()
+{
+  delete []_text;
+  _text = 0;
+  _ids.Clear();
+  _offsets.Clear();
+}
+
+static const wchar_t *kLangSignature = L";!@Lang2@!UTF-8!";
+
+bool CLang::OpenFromString(const AString &s2)
 {
-  value = 0;
+  UString s;
+  if (!ConvertUTF8ToUnicode(s2, s))
+    return false;
+  unsigned i = 0;
   if (s.IsEmpty())
     return false;
-  for (int i = 0; i < s.Length(); i++)
+  if (s[0] == 0xFEFF)
+    i++;
+
+  for (const wchar_t *p = kLangSignature;; i++)
   {
-    wchar_t c = s[i];
-    int a;
-    if (c >= L'0' && c <= L'9')
-      a = c - L'0';
-    else if (c >= L'A' && c <= L'F')
-      a = 10 + c - L'A';
-    else if (c >= L'a' && c <= L'f')
-      a = 10 + c - L'a';
-    else
+    wchar_t c = *p++;
+    if (c == 0)
+      break;
+    if (s[i] != c)
       return false;
-    value *= 0x10;
-    value += a;
   }
-  return true;
-}
 
+  _text = new wchar_t[s.Len() - i + 1];
+  wchar_t *text = _text;
 
-static bool WaitNextLine(const AString &s, int &pos)
-{
-  for (; pos < s.Length(); pos++)
-    if (s[pos] == 0x0A)
-      return true;
-  return false;
-}
+  Int32 id = -100;
+  UInt32 pos = 0;
 
-static int CompareLangItems(void *const *elem1, void *const *elem2, void *)
-{
-  const CLangPair &langPair1 = *(*((const CLangPair **)elem1));
-  const CLangPair &langPair2 = *(*((const CLangPair **)elem2));
-  return MyCompare(langPair1.Value, langPair2.Value);
+  while (i < s.Len())
+  {
+    unsigned start = pos;
+    do
+    {
+      wchar_t c = s[i++];
+      if (c == '\n')
+        break;
+      if (c == '\\')
+      {
+        if (i == s.Len())
+          return false;
+        c = s[i++];
+        switch (c)
+        {
+          case '\n': return false;
+          case 'n': c = '\n'; break;
+          case 't': c = '\t'; break;
+          case '\\': c = '\\'; break;
+          default: text[pos++] = L'\\'; break;
+        }
+      }
+      text[pos++] = c;
+    }
+    while (i < s.Len());
+
+    {
+      unsigned j = start;
+      for (; j < pos; j++)
+        if (text[j] != ' ')
+          break;
+      if (j == pos)
+      {
+        id++;
+        continue;
+      }
+    }
+    if (text[start] == ';')
+    {
+      pos = start;
+      id++;
+      continue;
+    }
+    
+    text[pos++] = 0;
+    const wchar_t *end;
+    UInt32 id32 = ConvertStringToUInt32(text + start, &end);
+    if (*end == 0)
+    {
+      if (id32 > ((UInt32)1 << 30) || (Int32)id32 < id)
+        return false;
+      id = (Int32)id32;
+      pos = start;
+      continue;
+    }
+
+    if (id < 0)
+      return false;
+    _ids.Add((UInt32)id++);
+    _offsets.Add(start);
+  }
+
+  return true;
 }
 
-bool CLang::Open(LPCWSTR fileName)
+bool CLang::Open(CFSTR fileName, const wchar_t *id)
 {
-  _langPairs.Clear();
+  Clear();
   NWindows::NFile::NIO::CInFile file;
   if (!file.Open(fileName))
     return false;
@@ -59,72 +120,44 @@ bool CLang::Open(LPCWSTR fileName)
     return false;
   if (length > (1 << 20))
     return false;
+  
   AString s;
-  char *p = s.GetBuffer((int)length + 1);
+  unsigned len = (unsigned)length;
+  char *p = s.GetBuf(len);
   UInt32 processed;
-  if (!file.Read(p, (UInt32)length, processed))
+  if (!file.Read(p, len, processed))
     return false;
-  p[(UInt32)length] = 0;
-  s.ReleaseBuffer();
   file.Close();
-  int pos = 0;
-  if (s.Length() >= 3)
-  {
-    if (Byte(s[0]) == 0xEF && Byte(s[1]) == 0xBB && Byte(s[2]) == 0xBF)
-      pos += 3;
-  }
-
-  /////////////////////
-  // read header
-
-  AString stringID = ";!@Lang@!UTF-8!";
-  if (s.Mid(pos, stringID.Length()) != stringID)
-    return false;
-  pos += stringID.Length();
-  
-  if (!WaitNextLine(s, pos))
+  if (len != processed)
     return false;
 
-  CObjectVector<CTextConfigPair> pairs;
-  if (!GetTextConfig(s.Mid(pos), pairs))
-    return false;
-
-  _langPairs.Reserve(_langPairs.Size());
-  for (int i = 0; i < pairs.Size(); i++)
+  char *p2 = p;
+  for (unsigned i = 0; i < len; i++)
   {
-    CTextConfigPair textConfigPair = pairs[i];
-    CLangPair langPair;
-    if (!HexStringToNumber(textConfigPair.ID, langPair.Value))
-      return false;
-    langPair.String = textConfigPair.String;
-    _langPairs.Add(langPair);
+    char c = p[i];
+    if (c == 0)
+      break;
+    if (c != 0x0D)
+      *p2++ = c;
   }
-  _langPairs.Sort(CompareLangItems, NULL);
-  return true;
-}
-
-int CLang::FindItem(UInt32 value) const
-{
-  int left = 0, right = _langPairs.Size();
-  while (left != right)
+  *p2 = 0;
+  s.ReleaseBuf_SetLen((unsigned)(p2 - p));
+  
+  if (OpenFromString(s))
   {
-    UInt32 mid = (left + right) / 2;
-    UInt32 midValue = _langPairs[mid].Value;
-    if (value == midValue)
-      return mid;
-    if (value < midValue)
-      right = mid;
-    else
-      left = mid + 1;
+    const wchar_t *name = Get(0);
+    if (name && wcscmp(name, id) == 0)
+      return true;
   }
-  return -1;
+  
+  Clear();
+  return false;
 }
 
-bool CLang::GetMessage(UInt32 value, UString &message) const
+const wchar_t *CLang::Get(UInt32 id) const throw()
 {
-  int index =  FindItem(value);
+  int index = _ids.FindInSorted(id);
   if (index < 0)
-    return false;
-  message = _langPairs[index].String;
-  return true;
+    return NULL;
+  return _text + (size_t)_offsets[index];
 }

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

@@ -3,26 +3,21 @@
 #ifndef __COMMON_LANG_H
 #define __COMMON_LANG_H
 
-#include "MyVector.h"
 #include "MyString.h"
-#include "Types.h"
-
-struct CLangPair
-{
-  UInt32 Value;
-  UString String;
-};
 
 class CLang
 {
-  CObjectVector<CLangPair> _langPairs;
+  wchar_t *_text;
+  CRecordVector<UInt32> _ids;
+  CRecordVector<UInt32> _offsets;
+
+  bool OpenFromString(const AString &s);
 public:
-  bool Open(LPCWSTR fileName);
-  void Clear() { _langPairs.Clear(); }
-  int FindItem(UInt32 value) const;
-  bool GetMessage(UInt32 value, UString &message) const;
+  CLang(): _text(0) {}
+  ~CLang() { Clear(); }
+  bool Open(CFSTR fileName, const wchar_t *id);
+  void Clear() throw();
+  const wchar_t *Get(UInt32 id) const throw();
 };
 
 #endif
-
-

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

@@ -2,74 +2,116 @@
 
 #include "StdAfx.h"
 
-#include "MyWindows.h"
+#include "../../C/CpuArch.h"
+
 #include "../Windows/FileIO.h"
 
 #include "ListFileUtils.h"
+#include "MyBuffer.h"
 #include "StringConvert.h"
 #include "UTFConvert.h"
 
-static const char kQuoteChar     = '\"';
-static void RemoveQuote(UString &s)
+static const char kQuoteChar = '\"';
+
+static void AddName(UStringVector &strings, UString &s)
 {
-  if (s.Length() >= 2)
-    if (s[0] == kQuoteChar && s[s.Length() - 1] == kQuoteChar)
-      s = s.Mid(1, s.Length() - 2);
+  s.Trim();
+  if (s.Len() >= 2 && s[0] == kQuoteChar && s.Back() == kQuoteChar)
+  {
+    s.DeleteBack();
+    s.Delete(0);
+  }
+  if (!s.IsEmpty())
+    strings.Add(s);
 }
 
-bool ReadNamesFromListFile(LPCWSTR fileName, UStringVector &resultStrings, UINT codePage)
+bool ReadNamesFromListFile(CFSTR fileName, UStringVector &strings, UINT codePage)
 {
   NWindows::NFile::NIO::CInFile file;
-  if (!file.Open(fileName,true)) /* follow the symbolic link */
+  if (!file.Open(fileName,true))  /* follow the symbolic link */
     return false;
-  UInt64 length;
-  if (!file.GetLength(length))
+  UInt64 fileSize;
+  if (!file.GetLength(fileSize))
     return false;
-  if (length > ((UInt32)1 << 31))
+  if (fileSize >= ((UInt32)1 << 31) - 32)
     return false;
-  AString s;
-  char *p = s.GetBuffer((int)length + 1);
-  UInt32 processed;
-  if (!file.Read(p, (UInt32)length, processed))
-    return false;
-  p[(UInt32)length] = 0;
-  s.ReleaseBuffer();
-  file.Close();
-
   UString u;
-  #ifdef CP_UTF8
-  if (codePage == CP_UTF8)
+  if (codePage == MY__CP_UTF16 || codePage == MY__CP_UTF16BE)
   {
-    if (!ConvertUTF8ToUnicode(s, u))
+    if ((fileSize & 1) != 0)
+      return false;
+    CByteArr buf((size_t)fileSize);
+    UInt32 processed;
+    if (!file.Read(buf, (UInt32)fileSize, processed))
+      return false;
+    if (processed != fileSize)
       return false;
+    file.Close();
+    unsigned num = (unsigned)fileSize / 2;
+    wchar_t *p = u.GetBuf(num);
+    if (codePage == MY__CP_UTF16)
+      for (unsigned i = 0; i < num; i++)
+      {
+        wchar_t c = GetUi16(buf + i * 2);
+        if (c == 0)
+          return false;
+        p[i] = c;
+      }
+    else
+      for (unsigned i = 0; i < num; i++)
+      {
+        wchar_t c = (wchar_t)GetBe16(buf + i * 2);
+        if (c == 0)
+          return false;
+        p[i] = c;
+      }
+    p[num] = 0;
+    u.ReleaseBuf_SetLen(num);
   }
   else
-  #endif
-    u = MultiByteToUnicodeString(s, codePage);
-  if (!u.IsEmpty())
   {
-    if (u[0] == 0xFEFF)
-      u.Delete(0);
+    AString s;
+    char *p = s.GetBuf((unsigned)fileSize);
+    UInt32 processed;
+    if (!file.Read(p, (UInt32)fileSize, processed))
+      return false;
+    if (processed != fileSize)
+      return false;
+    file.Close();
+    s.ReleaseBuf_CalcLen((unsigned)processed);
+    if (s.Len() != processed)
+      return false;
+    
+    // #ifdef CP_UTF8
+    if (codePage == CP_UTF8)
+    {
+      if (!ConvertUTF8ToUnicode(s, u))
+        return false;
+    }
+    else
+    // #endif
+      MultiByteToUnicodeString2(u, s, codePage);
   }
 
-  UString t;
-  for (int i = 0; i < u.Length(); i++)
+  const wchar_t kGoodBOM = 0xFEFF;
+  const wchar_t kBadBOM  = 0xFFFE;
+  
+  UString s;
+  unsigned i = 0;
+  for (; i < u.Len() && u[i] == kGoodBOM; i++);
+  for (; i < u.Len(); i++)
   {
     wchar_t c = u[i];
+    if (c == kGoodBOM || c == kBadBOM)
+      return false;
     if (c == L'\n' || c == 0xD)
     {
-      t.Trim();
-      RemoveQuote(t);
-      if (!t.IsEmpty())
-        resultStrings.Add(t);
-      t.Empty();
+      AddName(strings, s);
+      s.Empty();
     }
     else
-      t += c;
+      s += c;
   }
-  t.Trim();
-  RemoveQuote(t);
-  if (!t.IsEmpty())
-    resultStrings.Add(t);
+  AddName(strings, s);
   return true;
 }

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

@@ -1,11 +1,14 @@
 // Common/ListFileUtils.h
 
-#ifndef __COMMON_LISTFILEUTILS_H
-#define __COMMON_LISTFILEUTILS_H
+#ifndef __COMMON_LIST_FILE_UTILS_H
+#define __COMMON_LIST_FILE_UTILS_H
 
 #include "MyString.h"
-#include "Types.h"
+#include "MyTypes.h"
 
-bool ReadNamesFromListFile(LPCWSTR fileName, UStringVector &strings, UINT codePage = CP_OEMCP);
+#define MY__CP_UTF16   1200
+#define MY__CP_UTF16BE 1201
+
+bool ReadNamesFromListFile(CFSTR fileName, UStringVector &strings, UINT codePage = CP_OEMCP);
 
 #endif

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

@@ -0,0 +1,244 @@
+// Common/MyBuffer.h
+
+#ifndef __COMMON_MY_BUFFER_H
+#define __COMMON_MY_BUFFER_H
+
+#include "Defs.h"
+
+template <class T> class CBuffer
+{
+  T *_items;
+  size_t _size;
+
+public:
+  void Free()
+  {
+    if (_items)
+    {
+      delete []_items;
+      _items = 0;
+    }
+    _size = 0;
+  }
+  
+  CBuffer(): _items(0), _size(0) {};
+  CBuffer(size_t size): _items(0), _size(0) { _items = new T[size]; _size = size; }
+  CBuffer(const CBuffer &buffer): _items(0), _size(0)
+  {
+    size_t size = buffer._size;
+    if (size != 0)
+    {
+      _items = new T[size];
+      memcpy(_items, buffer._items, size * sizeof(T));
+      _size = size;
+    }
+  }
+
+  ~CBuffer() { delete []_items; }
+
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  size_t Size() const { return _size; }
+
+  void Alloc(size_t size)
+  {
+    if (size != _size)
+    {
+      Free();
+      if (size != 0)
+      {
+        _items = new T[size];
+        _size = size;
+      }
+    }
+  }
+
+  void AllocAtLeast(size_t size)
+  {
+    if (size > _size)
+    {
+      Free();
+      _items = new T[size];
+      _size = size;
+    }
+  }
+
+  void CopyFrom(const T *data, size_t size)
+  {
+    Alloc(size);
+    if (size != 0)
+      memcpy(_items, data, size * sizeof(T));
+  }
+
+  void ChangeSize_KeepData(size_t newSize, size_t keepSize)
+  {
+    if (newSize == _size)
+      return;
+    T *newBuffer = NULL;
+    if (newSize != 0)
+    {
+      newBuffer = new T[newSize];
+      if (keepSize > _size)
+        keepSize = _size;
+      if (keepSize != 0)
+        memcpy(newBuffer, _items, MyMin(keepSize, newSize) * sizeof(T));
+    }
+    delete []_items;
+    _items = newBuffer;
+    _size = newSize;
+  }
+
+  CBuffer& operator=(const CBuffer &buffer)
+  {
+    if (&buffer != this)
+      CopyFrom(buffer, buffer._size);
+    return *this;
+  }
+};
+
+template <class T>
+bool operator==(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+  size_t size1 = b1.Size();
+  if (size1 != b2.Size())
+    return false;
+  if (size1 == 0)
+    return true;
+  return memcmp(b1, b2, size1 * sizeof(T)) == 0;
+}
+
+template <class T>
+bool operator!=(const CBuffer<T>& b1, const CBuffer<T>& b2)
+{
+  size_t size1 = b1.Size();
+  if (size1 != b2.Size())
+    return true;
+  if (size1 == 0)
+    return false;
+  return memcmp(b1, b2, size1 * sizeof(T)) != 0;
+}
+
+
+typedef CBuffer<char> CCharBuffer;
+// typedef CBuffer<wchar_t> CWCharBuffer;
+typedef CBuffer<unsigned char> CByteBuffer;
+
+
+template <class T> class CObjArray
+{
+protected:
+  T *_items;
+private:
+  // we disable constructors
+  CObjArray(const CObjArray &buffer);
+  void operator=(const CObjArray &buffer);
+public:
+  void Free()
+  {
+    delete []_items;
+    _items = 0;
+  }
+  CObjArray(size_t size): _items(0) { if (size != 0) _items = new T[size]; }
+  CObjArray(): _items(0) {};
+  ~CObjArray() { delete []_items; }
+  
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  
+  void Alloc(size_t newSize)
+  {
+    delete []_items;
+    _items = 0;
+    _items = new T[newSize];
+  }
+};
+
+typedef CObjArray<unsigned char> CByteArr;
+typedef CObjArray<bool> CBoolArr;
+typedef CObjArray<int> CIntArr;
+typedef CObjArray<unsigned> CUIntArr;
+
+
+template <class T> class CObjArray2
+{
+  T *_items;
+  unsigned _size;
+
+  CObjArray2(const CObjArray2 &buffer);
+  void operator=(const CObjArray2 &buffer);
+public:
+  
+  void Free()
+  {
+    delete []_items;
+    _items = 0;
+    _size = 0;
+  }
+  CObjArray2(): _items(0), _size(0) {};
+  /*
+  CObjArray2(const CObjArray2 &buffer): _items(0), _size(0)
+  {
+    size_t newSize = buffer._size;
+    if (newSize != 0)
+    {
+      T *newBuffer = new T[newSize];;
+      _items = newBuffer;
+      _size = newSize;
+      const T *src = buffer;
+      for (size_t i = 0; i < newSize; i++)
+        newBuffer[i] = src[i];
+    }
+  }
+  */
+  /*
+  CObjArray2(size_t size): _items(0), _size(0)
+  {
+    if (size != 0)
+    {
+      _items = new T[size];
+      _size = size;
+    }
+  }
+  */
+
+  ~CObjArray2() { delete []_items; }
+  
+  operator       T *()       { return _items; }
+  operator const T *() const { return _items; }
+  
+  unsigned Size() const { return (unsigned)_size; }
+  bool IsEmpty() const { return _size == 0; }
+
+  // SetSize doesn't keep old items. It allocates new array if size is not equal
+  void SetSize(unsigned size)
+  {
+    if (size == _size)
+      return;
+    T *newBuffer = NULL;
+    if (size != 0)
+      newBuffer = new T[size];
+    delete []_items;
+    _items = newBuffer;
+    _size = size;
+  }
+
+  /*
+  CObjArray2& operator=(const CObjArray2 &buffer)
+  {
+    Free();
+    size_t newSize = buffer._size;
+    if (newSize != 0)
+    {
+      T *newBuffer = new T[newSize];;
+      _items = newBuffer;
+      _size = newSize;
+      const T *src = buffer;
+      for (size_t i = 0; i < newSize; i++)
+        newBuffer[i] = src[i];
+    }
+    return *this;
+  }
+  */
+};
+
+#endif