seven-zip 1.4.0

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

@@ -0,0 +1,209 @@
+// MyXml.cpp
+
+#include "StdAfx.h"
+
+#include "MyXml.h"
+
+static bool IsValidChar(char c)
+{
+  return
+    c >= 'a' && c <= 'z' ||
+    c >= 'A' && c <= 'Z' ||
+    c >= '0' && c <= '9' ||
+    c == '-';
+}
+
+static bool IsSpaceChar(char c)
+{
+  return (c == ' ' || c == '\t' || c == 0x0D || c == 0x0A);
+}
+
+#define SKIP_SPACES(s, pos) while (IsSpaceChar(s[pos])) pos++;
+
+static bool ReadProperty(const AString &s, int &pos, CXmlProp &prop)
+{
+  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++)
+    if (Props[i].Name == propName)
+      return i;
+  return -1;
+}
+
+AString CXmlItem::GetPropertyValue(const AString &propName) const
+{
+  int index = FindProperty(propName);
+  if (index >= 0)
+    return Props[index].Value;
+  return AString();
+}
+
+bool CXmlItem::IsTagged(const AString &tag) const
+{
+  return (IsTag && Name == tag);
+}
+
+int CXmlItem::FindSubTag(const AString &tag) const
+{
+  for (int i = 0; i < SubItems.Size(); i++)
+    if (SubItems[i].IsTagged(tag))
+      return i;
+  return -1;
+}
+
+AString CXmlItem::GetSubString() const
+{
+  if (SubItems.Size() == 1)
+  {
+    const CXmlItem &item = SubItems[0];
+    if (!item.IsTag)
+      return item.Name;
+  }
+  return AString();
+}
+
+AString CXmlItem::GetSubStringForTag(const AString &tag) const
+{
+  int index = FindSubTag(tag);
+  if (index >= 0)
+    return SubItems[index].GetSubString();
+  return AString();
+}
+
+bool CXmlItem::ParseItems(const AString &s, int &pos, int numAllowedLevels)
+{
+  if (numAllowedLevels == 0)
+    return false;
+  SubItems.Clear();
+  AString finishString = "</";
+  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);
+  }
+}
+
+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)
+  {
+    IsTag = false;
+    Name += s.Mid(pos, pos2 - pos);
+    pos = pos2;
+    return true;
+  }
+  IsTag = true;
+
+  pos++;
+  SKIP_SPACES(s, pos);
+
+  for (; pos < s.Length(); pos++)
+  {
+    char c = s[pos];
+    if (!IsValidChar(c))
+      break;
+    Name += c;
+  }
+  if (Name.IsEmpty() || pos == s.Length())
+    return false;
+
+  int posTemp = pos;
+  for (;;)
+  {
+    SKIP_SPACES(s, pos);
+    if (s[pos] == '/')
+    {
+      pos++;
+      // SKIP_SPACES(s, pos);
+      return (s[pos++] == '>');
+    }
+    if (s[pos] == '>')
+    {
+      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;
+    }
+    if (posTemp == pos)
+      return false;
+
+    CXmlProp prop;
+    if (!ReadProperty(s, pos, prop))
+      return false;
+    Props.Add(prop);
+    posTemp = pos;
+  }
+}
+
+static bool SkipHeader(const AString &s, int &pos, const AString &startString, const AString &endString)
+{
+  SKIP_SPACES(s, pos);
+  if (s.Mid(pos, startString.Length()) == startString)
+  {
+    pos = s.Find(endString, pos);
+    if (pos < 0)
+      return false;
+    pos += endString.Length();
+    SKIP_SPACES(s, pos);
+  }
+  return true;
+}
+
+bool CXml::Parse(const AString &s)
+{
+  int pos = 0;
+  if (!SkipHeader(s, pos, "<?xml", "?>"))
+    return false;
+  if (!SkipHeader(s, pos, "<!DOCTYPE", ">"))
+    return false;
+  if (!Root.ParseItem(s, pos, 1000))
+    return false;
+  SKIP_SPACES(s, pos);
+  return (pos == s.Length() && Root.IsTag);
+}

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

@@ -0,0 +1,40 @@
+// MyXml.h
+
+#ifndef __MYXML_H
+#define __MYXML_H
+
+#include "MyString.h"
+
+struct CXmlProp
+{
+  AString Name;
+  AString Value;
+};
+
+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;
+  AString GetSubString() const;
+  int FindSubTag(const AString &tag) const;
+  AString GetSubStringForTag(const AString &tag) const;
+};
+
+struct CXml
+{
+  CXmlItem Root;
+  bool Parse(const AString &s);
+};
+
+#endif

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

@@ -0,0 +1,16 @@
+// Common/NewHandler.h
+
+#ifndef __COMMON_NEWHANDLER_H
+#define __COMMON_NEWHANDLER_H
+
+class CNewException {};
+
+#ifdef _WIN32
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw();
+#endif
+
+#endif

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

@@ -0,0 +1,100 @@
+// Common/StdInStream.cpp
+
+#include "StdAfx.h"
+
+#include <tchar.h>
+#include "StdInStream.h"
+
+#ifdef _MSC_VER
+// "was declared deprecated" disabling
+#pragma warning(disable : 4996 )
+#endif
+
+#ifdef _UNICODE
+#include "Common/StringConvert.h"
+#define NEED_NAME_WINDOWS_TO_UNIX
+#include "myPrivate.h"
+#endif
+
+static const char kIllegalChar = '\0';
+static const char kNewLineChar = '\n';
+
+static const char *kEOFMessage = "Unexpected end of input stream";
+static const char *kReadErrorMessage  ="Error reading input stream";
+static const char *kIllegalCharMessage = "Illegal character in input stream";
+
+static const char * kFileOpenMode = "r";
+
+CStdInStream g_StdIn(stdin);
+
+bool CStdInStream::Open(LPCTSTR fileName)
+{
+  Close();
+#ifdef _UNICODE
+  AString aStr = UnicodeStringToMultiByte(fileName, CP_ACP); // FIXME
+  const char * name = nameWindowToUnix(aStr);
+#else
+  const char * name = nameWindowToUnix(fileName);
+#endif
+  _stream = fopen(name, kFileOpenMode);
+  _streamIsOpen = (_stream != 0);
+  return _streamIsOpen;
+}
+
+bool CStdInStream::Close()
+{
+  if (!_streamIsOpen)
+    return true;
+  _streamIsOpen = (fclose(_stream) != 0);
+  return !_streamIsOpen;
+}
+
+CStdInStream::~CStdInStream()
+{
+  Close();
+}
+
+AString CStdInStream::ScanStringUntilNewLine(bool allowEOF)
+{
+  AString s;
+  for (;;)
+  {
+    int intChar = GetChar();
+    if (intChar == EOF)
+    {
+      if (allowEOF)
+        break;
+      throw kEOFMessage;
+    }
+    char c = char(intChar);
+    if (c == kIllegalChar)
+      throw kIllegalCharMessage;
+    if (c == kNewLineChar)
+      break;
+    s += c;
+  }
+  return s;
+}
+
+void CStdInStream::ReadToString(AString &resultString)
+{
+  resultString.Empty();
+  int c;
+  while ((c = GetChar()) != EOF)
+    resultString += char(c);
+}
+
+bool CStdInStream::Eof()
+{
+  return (feof(_stream) != 0);
+}
+
+int CStdInStream::GetChar()
+{
+  int c = fgetc(_stream); // getc() doesn't work in BeOS?
+  if (c == EOF && !Eof())
+    throw kReadErrorMessage;
+  return c;
+}
+
+

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

@@ -0,0 +1,32 @@
+// Common/StdInStream.h
+
+#ifndef __COMMON_STDINSTREAM_H
+#define __COMMON_STDINSTREAM_H
+
+#include <stdio.h>
+
+#include "MyString.h"
+#include "Types.h"
+
+class CStdInStream
+{
+  bool _streamIsOpen;
+  FILE *_stream;
+public:
+  CStdInStream(): _streamIsOpen(false) {};
+  CStdInStream(FILE *stream): _streamIsOpen(false), _stream(stream) {};
+  ~CStdInStream();
+  bool Open(LPCTSTR fileName);
+  bool Close();
+
+  AString ScanStringUntilNewLine(bool allowEOF = false);
+  void ReadToString(AString &resultString);
+  UString ScanUStringUntilNewLine();
+
+  bool Eof();
+  int GetChar();
+};
+
+extern CStdInStream g_StdIn;
+
+#endif

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

@@ -0,0 +1,93 @@
+// Common/StdOutStream.cpp
+
+#include "StdAfx.h"
+
+#include <tchar.h>
+
+#include "StdOutStream.h"
+#include "IntToString.h"
+#include "StringConvert.h"
+
+#ifdef _MSC_VER
+// "was declared deprecated" disabling
+#pragma warning(disable : 4996 )
+#endif
+
+static const char kNewLineChar =  '\n';
+
+static const char *kFileOpenMode = "wt";
+
+CStdOutStream  g_StdOut(stdout);
+CStdOutStream  g_StdErr(stderr);
+
+bool CStdOutStream::Open(const char *fileName)
+{
+  Close();
+  _stream = fopen(fileName, kFileOpenMode);
+  _streamIsOpen = (_stream != 0);
+  return _streamIsOpen;
+}
+
+bool CStdOutStream::Close()
+{
+  if (!_streamIsOpen)
+    return true;
+  if (fclose(_stream) != 0)
+    return false;
+  _stream = 0;
+  _streamIsOpen = false;
+  return true;
+}
+
+bool CStdOutStream::Flush()
+{
+  return (fflush(_stream) == 0);
+}
+
+CStdOutStream::~CStdOutStream ()
+{
+  Close();
+}
+
+CStdOutStream & CStdOutStream::operator<<(CStdOutStream & (*aFunction)(CStdOutStream  &))
+{
+  (*aFunction)(*this);
+  return *this;
+}
+
+CStdOutStream & endl(CStdOutStream & outStream)
+{
+  return outStream << kNewLineChar;
+}
+
+CStdOutStream & CStdOutStream::operator<<(const char *string)
+{
+  fputs(string, _stream);
+  return *this;
+}
+
+CStdOutStream & CStdOutStream::operator<<(const wchar_t *string)
+{
+  *this << (const char *)UnicodeStringToMultiByte(string, CP_OEMCP);
+  return *this;
+}
+
+CStdOutStream & CStdOutStream::operator<<(char c)
+{
+  fputc(c, _stream);
+  return *this;
+}
+
+CStdOutStream & CStdOutStream::operator<<(int number)
+{
+  char textString[32];
+  ConvertInt64ToString(number, textString);
+  return operator<<(textString);
+}
+
+CStdOutStream & CStdOutStream::operator<<(UInt64 number)
+{
+  char textString[32];
+  ConvertUInt64ToString(number, textString);
+  return operator<<(textString);
+}

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

@@ -0,0 +1,35 @@
+// Common/StdOutStream.h
+
+#ifndef __COMMON_STDOUTSTREAM_H
+#define __COMMON_STDOUTSTREAM_H
+
+#include <stdio.h>
+
+#include "Types.h"
+
+class CStdOutStream
+{
+  bool _streamIsOpen;
+  FILE *_stream;
+public:
+  CStdOutStream (): _streamIsOpen(false), _stream(0) {};
+  CStdOutStream (FILE *stream): _streamIsOpen(false), _stream(stream) {};
+  ~CStdOutStream ();
+  operator FILE *() { return _stream; }
+  bool Open(const char *fileName);
+  bool Close();
+  bool Flush();
+  CStdOutStream & operator<<(CStdOutStream & (* aFunction)(CStdOutStream  &));
+  CStdOutStream & operator<<(const char *string);
+  CStdOutStream & operator<<(const wchar_t *string);
+  CStdOutStream & operator<<(char c);
+  CStdOutStream & operator<<(int number);
+  CStdOutStream & operator<<(UInt64 number);
+};
+
+CStdOutStream & endl(CStdOutStream & outStream);
+
+extern CStdOutStream g_StdOut;
+extern CStdOutStream g_StdErr;
+
+#endif

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

@@ -0,0 +1,181 @@
+// Common/StringConvert.cpp
+
+#include "StdAfx.h"
+#include <stdlib.h>
+
+#include "StringConvert.h"
+extern "C"
+{
+int global_use_utf16_conversion = 0;
+}
+
+
+#ifdef LOCALE_IS_UTF8
+
+#ifdef __APPLE_CC__
+#define UInt32  macUIn32
+#include <CoreFoundation/CoreFoundation.h>
+#undef UInt32
+
+UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
+{
+  if (!srcString.IsEmpty())
+  {
+    UString resultString;
+    const char * path = &srcString[0];
+
+// FIXME    size_t n = strlen(path);
+
+    CFStringRef cfpath = CFStringCreateWithCString(NULL,path,kCFStringEncodingUTF8);
+
+    if (cfpath)
+    {
+
+       CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
+       CFRelease(cfpath);
+       CFStringNormalize(cfpath2,kCFStringNormalizationFormC);
+    
+       size_t n = CFStringGetLength(cfpath2);
+       for(size_t i =   0 ; i< n ;i++) {
+         resultString += CFStringGetCharacterAtIndex(cfpath2,i);
+       }
+
+       CFRelease(cfpath2);  
+
+       return resultString;
+    }
+  }
+
+  UString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+    resultString += wchar_t(srcString[i] & 255);
+
+  return resultString;
+}
+
+AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage)
+{
+  if (!srcString.IsEmpty())
+  {
+    const wchar_t * wcs = &srcString[0];
+    char utf8[4096];
+    UniChar unipath[4096];
+
+    size_t n = wcslen(wcs);
+
+    for(size_t i =   0 ; i<= n ;i++) {
+      unipath[i] = wcs[i];
+    }
+
+    CFStringRef cfpath = CFStringCreateWithCharacters(NULL,unipath,n);
+
+    CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
+    CFRelease(cfpath);
+    CFStringNormalize(cfpath2,kCFStringNormalizationFormD);
+    
+    CFStringGetCString(cfpath2,(char *)utf8,4096,kCFStringEncodingUTF8);
+
+    CFRelease(cfpath2);  
+
+    return AString(utf8);
+  }
+
+  AString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+  {
+    if (srcString[i] >= 256) resultString += '?';
+    else                     resultString += char(srcString[i]);
+  }
+  return resultString;
+}
+
+#else /* __APPLE_CC__ */
+
+
+#include "UTFConvert.h"
+
+UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
+{
+  if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
+  {
+    UString resultString;
+    bool bret = ConvertUTF8ToUnicode(srcString,resultString);
+    if (bret) return resultString;
+  }
+
+  UString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+    resultString += wchar_t(srcString[i] & 255);
+
+  return resultString;
+}
+
+AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage)
+{
+  if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
+  {
+    AString resultString;
+    bool bret = ConvertUnicodeToUTF8(srcString,resultString);
+    if (bret) return resultString;
+  }
+
+  AString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+  {
+    if (srcString[i] >= 256) resultString += '?';
+    else                     resultString += char(srcString[i]);
+  }
+  return resultString;
+}
+
+#endif /* __APPLE_CC__ */
+
+#else /* LOCALE_IS_UTF8 */
+
+UString MultiByteToUnicodeString(const AString &srcString, UINT /* codePage */ )
+{
+#ifdef ENV_HAVE_MBSTOWCS
+  if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
+  {
+    UString resultString;
+    int numChars = mbstowcs(resultString.GetBuffer(srcString.Length()),srcString,srcString.Length()+1);
+    if (numChars >= 0) {
+      resultString.ReleaseBuffer(numChars);
+      return resultString;
+    }
+  }
+#endif
+
+  UString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+    resultString += wchar_t(srcString[i] & 255);
+
+  return resultString;
+}
+
+AString UnicodeStringToMultiByte(const UString &srcString, UINT /* codePage */ )
+{
+#ifdef ENV_HAVE_WCSTOMBS
+  if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
+  {
+    AString resultString;
+    int numRequiredBytes = srcString.Length() * 6+1;
+    int numChars = wcstombs(resultString.GetBuffer(numRequiredBytes),srcString,numRequiredBytes);
+    if (numChars >= 0) {
+      resultString.ReleaseBuffer(numChars);
+      return resultString;
+    }
+  }
+#endif
+
+  AString resultString;
+  for (int i = 0; i < srcString.Length(); i++)
+  {
+    if (srcString[i] >= 256) resultString += '?';
+    else                     resultString += char(srcString[i]);
+  }
+  return resultString;
+}
+
+#endif /* LOCALE_IS_UTF8 */
+