seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -3,45 +3,44 @@
 #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
+#include "StdInStream.h"
+#include "StringConvert.h"
+#include "UTFConvert.h"
 
-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";
+// static LPCTSTR kFileOpenMode = TEXT("r");
+
+// extern int g_CodePage;
+
+#ifdef _UNICODE
+#define NEED_NAME_WINDOWS_TO_UNIX
+#include "myPrivate.h"
+#endif
 
 CStdInStream g_StdIn(stdin);
 
-bool CStdInStream::Open(LPCTSTR fileName)
+bool CStdInStream::Open(LPCTSTR fileName) throw()
 {
   Close();
+//  _stream = _tfopen(fileName, kFileOpenMode);
 #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);
+  _stream = fopen(name, "r");
   _streamIsOpen = (_stream != 0);
   return _streamIsOpen;
 }
 
-bool CStdInStream::Close()
+bool CStdInStream::Close() throw()
 {
   if (!_streamIsOpen)
     return true;
@@ -49,11 +48,6 @@ bool CStdInStream::Close()
   return !_streamIsOpen;
 }
 
-CStdInStream::~CStdInStream()
-{
-  Close();
-}
-
 AString CStdInStream::ScanStringUntilNewLine(bool allowEOF)
 {
   AString s;
@@ -66,8 +60,8 @@ AString CStdInStream::ScanStringUntilNewLine(bool allowEOF)
         break;
       throw kEOFMessage;
     }
-    char c = char(intChar);
-    if (c == kIllegalChar)
+    char c = (char)intChar;
+    if (c == 0)
       throw kIllegalCharMessage;
     if (c == kNewLineChar)
       break;
@@ -76,15 +70,42 @@ AString CStdInStream::ScanStringUntilNewLine(bool allowEOF)
   return s;
 }
 
+#ifdef _WIN32
+UString CStdInStream::ScanUStringUntilNewLine()
+{
+  AString s = ScanStringUntilNewLine(true);
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  UString dest;
+  if (codePage == CP_UTF8)
+    ConvertUTF8ToUnicode(s, dest);
+  else
+    dest = MultiByteToUnicodeString(s, (UINT)codePage);
+  return dest;
+}
+#else
+
+#ifndef ENV_HAVE_GETPASS
+UString CStdInStream::ScanUStringUntilNewLine()
+{
+  AString s = ScanStringUntilNewLine(true);
+  UString dest = MultiByteToUnicodeString(s, (UINT)-1);
+  return dest;
+}
+#endif
+
+#endif
+
 void CStdInStream::ReadToString(AString &resultString)
 {
   resultString.Empty();
   int c;
   while ((c = GetChar()) != EOF)
-    resultString += char(c);
+    resultString += (char)c;
 }
 
-bool CStdInStream::Eof()
+bool CStdInStream::Eof() throw()
 {
   return (feof(_stream) != 0);
 }
@@ -96,5 +117,3 @@ int CStdInStream::GetChar()
     throw kReadErrorMessage;
   return c;
 }
-
-

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

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

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

@@ -4,23 +4,21 @@
 
 #include <tchar.h>
 
-#include "StdOutStream.h"
 #include "IntToString.h"
+#include "StdOutStream.h"
 #include "StringConvert.h"
-
-#ifdef _MSC_VER
-// "was declared deprecated" disabling
-#pragma warning(disable : 4996 )
-#endif
+#include "UTFConvert.h"
 
 static const char kNewLineChar =  '\n';
 
 static const char *kFileOpenMode = "wt";
 
-CStdOutStream  g_StdOut(stdout);
-CStdOutStream  g_StdErr(stderr);
+extern int g_CodePage;
+
+CStdOutStream g_StdOut(stdout);
+CStdOutStream g_StdErr(stderr);
 
-bool CStdOutStream::Open(const char *fileName)
+bool CStdOutStream::Open(const char *fileName) throw()
 {
   Close();
   _stream = fopen(fileName, kFileOpenMode);
@@ -28,7 +26,7 @@ bool CStdOutStream::Open(const char *fileName)
   return _streamIsOpen;
 }
 
-bool CStdOutStream::Close()
+bool CStdOutStream::Close() throw()
 {
   if (!_streamIsOpen)
     return true;
@@ -39,55 +37,70 @@ bool CStdOutStream::Close()
   return true;
 }
 
-bool CStdOutStream::Flush()
+bool CStdOutStream::Flush() throw()
 {
   return (fflush(_stream) == 0);
 }
 
-CStdOutStream::~CStdOutStream ()
+CStdOutStream & endl(CStdOutStream & outStream) throw()
 {
-  Close();
+  return outStream << kNewLineChar;
 }
 
-CStdOutStream & CStdOutStream::operator<<(CStdOutStream & (*aFunction)(CStdOutStream  &))
+CStdOutStream & CStdOutStream::operator<<(const wchar_t *s)
 {
-  (*aFunction)(*this);
-  return *this;
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  AString dest;
+  if (codePage == CP_UTF8)
+    ConvertUnicodeToUTF8(s, dest);
+  else
+    UnicodeStringToMultiByte2(dest, s, (UINT)codePage);
+  return operator<<((const char *)dest);
 }
 
-CStdOutStream & endl(CStdOutStream & outStream)
+void StdOut_Convert_UString_to_AString(const UString &s, AString &temp)
 {
-  return outStream << kNewLineChar;
+  int codePage = g_CodePage;
+  if (codePage == -1)
+    codePage = CP_OEMCP;
+  if (codePage == CP_UTF8)
+    ConvertUnicodeToUTF8(s, temp);
+  else
+    UnicodeStringToMultiByte2(temp, s, (UINT)codePage);
 }
 
-CStdOutStream & CStdOutStream::operator<<(const char *string)
+void CStdOutStream::PrintUString(const UString &s, AString &temp)
 {
-  fputs(string, _stream);
-  return *this;
+  StdOut_Convert_UString_to_AString(s, temp);
+  *this << (const char *)temp;
 }
 
-CStdOutStream & CStdOutStream::operator<<(const wchar_t *string)
+CStdOutStream & CStdOutStream::operator<<(Int32 number) throw()
 {
-  *this << (const char *)UnicodeStringToMultiByte(string, CP_OEMCP);
-  return *this;
+  char s[32];
+  ConvertInt64ToString(number, s);
+  return operator<<(s);
 }
 
-CStdOutStream & CStdOutStream::operator<<(char c)
+CStdOutStream & CStdOutStream::operator<<(Int64 number) throw()
 {
-  fputc(c, _stream);
-  return *this;
+  char s[32];
+  ConvertInt64ToString(number, s);
+  return operator<<(s);
 }
 
-CStdOutStream & CStdOutStream::operator<<(int number)
+CStdOutStream & CStdOutStream::operator<<(UInt32 number) throw()
 {
-  char textString[32];
-  ConvertInt64ToString(number, textString);
-  return operator<<(textString);
+  char s[16];
+  ConvertUInt32ToString(number, s);
+  return operator<<(s);
 }
 
-CStdOutStream & CStdOutStream::operator<<(UInt64 number)
+CStdOutStream & CStdOutStream::operator<<(UInt64 number) throw()
 {
-  char textString[32];
-  ConvertUInt64ToString(number, textString);
-  return operator<<(textString);
+  char s[32];
+  ConvertUInt64ToString(number, s);
+  return operator<<(s);
 }

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

@@ -1,35 +1,62 @@
 // Common/StdOutStream.h
 
-#ifndef __COMMON_STDOUTSTREAM_H
-#define __COMMON_STDOUTSTREAM_H
+#ifndef __COMMON_STD_OUT_STREAM_H
+#define __COMMON_STD_OUT_STREAM_H
 
 #include <stdio.h>
 
-#include "Types.h"
+#include "MyString.h"
+#include "MyTypes.h"
 
 class CStdOutStream
 {
-  bool _streamIsOpen;
   FILE *_stream;
+  bool _streamIsOpen;
 public:
-  CStdOutStream (): _streamIsOpen(false), _stream(0) {};
-  CStdOutStream (FILE *stream): _streamIsOpen(false), _stream(stream) {};
-  ~CStdOutStream ();
+  CStdOutStream(): _stream(0), _streamIsOpen(false) {};
+  CStdOutStream(FILE *stream): _stream(stream), _streamIsOpen(false) {};
+  ~CStdOutStream() { Close(); }
+
+  // void AttachStdStream(FILE *stream) { _stream  = stream; _streamIsOpen = false; }
+  // bool IsDefined() const { return _stream  != NULL; }
+
   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);
+  bool Open(const char *fileName) throw();
+  bool Close() throw();
+  bool Flush() throw();
+  
+  CStdOutStream & operator<<(CStdOutStream & (* func)(CStdOutStream  &))
+  {
+    (*func)(*this);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(const char *s) throw()
+  {
+    fputs(s, _stream);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(char c) throw()
+  {
+    fputc((unsigned char)c, _stream);
+    return *this;
+  }
+
+  CStdOutStream & operator<<(Int32 number) throw();
+  CStdOutStream & operator<<(Int64 number) throw();
+  CStdOutStream & operator<<(UInt32 number) throw();
+  CStdOutStream & operator<<(UInt64 number) throw();
+
+  CStdOutStream & operator<<(const wchar_t *s);
+  void PrintUString(const UString &s, AString &temp);
 };
 
-CStdOutStream & endl(CStdOutStream & outStream);
+CStdOutStream & endl(CStdOutStream & outStream) throw();
 
 extern CStdOutStream g_StdOut;
 extern CStdOutStream g_StdErr;
 
+void StdOut_Convert_UString_to_AString(const UString &s, AString &temp);
+
 #endif

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

@@ -1,7 +1,6 @@
 // Common/StringConvert.cpp
 
 #include "StdAfx.h"
-#include <stdlib.h>
 
 #include "StringConvert.h"
 extern "C"
@@ -9,7 +8,6 @@ extern "C"
 int global_use_utf16_conversion = 0;
 }
 
-
 #ifdef LOCALE_IS_UTF8
 
 #ifdef __APPLE_CC__
@@ -37,7 +35,8 @@ UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
     
        size_t n = CFStringGetLength(cfpath2);
        for(size_t i =   0 ; i< n ;i++) {
-         resultString += CFStringGetCharacterAtIndex(cfpath2,i);
+         UniChar uc = CFStringGetCharacterAtIndex(cfpath2,i);
+         resultString += (wchar_t)uc; // FIXME
        }
 
        CFRelease(cfpath2);  
@@ -47,7 +46,7 @@ UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
   }
 
   UString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
     resultString += wchar_t(srcString[i] & 255);
 
   return resultString;
@@ -81,7 +80,7 @@ AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage)
   }
 
   AString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
   {
     if (srcString[i] >= 256) resultString += '?';
     else                     resultString += char(srcString[i]);
@@ -104,7 +103,7 @@ UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
   }
 
   UString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
     resultString += wchar_t(srcString[i] & 255);
 
   return resultString;
@@ -115,12 +114,12 @@ 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;
+    ConvertUnicodeToUTF8(srcString,resultString);
+    return resultString;
   }
 
   AString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
   {
     if (srcString[i] >= 256) resultString += '?';
     else                     resultString += char(srcString[i]);
@@ -138,38 +137,67 @@ UString MultiByteToUnicodeString(const AString &srcString, UINT /* codePage */ )
   if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
   {
     UString resultString;
-    int numChars = mbstowcs(resultString.GetBuffer(srcString.Length()),srcString,srcString.Length()+1);
+    int numChars = mbstowcs(resultString.GetBuf(srcString.Len()),srcString,srcString.Len()+1);
     if (numChars >= 0) {
-      resultString.ReleaseBuffer(numChars);
+        resultString.ReleaseBuf_SetEnd(numChars);
+
+#if WCHAR_MAX > 0xffff
+      for (int i = numChars; i >= 0; i--) {
+        if (resultString[i] > 0xffff) {
+          wchar_t c = resultString[i] - 0x10000;
+          resultString.Delete(i);
+          wchar_t texts[]= { ((c >> 10) & 0x3ff) + 0xd800,  (c & 0x3ff) + 0xdc00 , 0 };
+          resultString.Insert(i, texts);
+          numChars++;
+        }
+      }
+#endif
+
       return resultString;
     }
   }
 #endif
 
   UString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
     resultString += wchar_t(srcString[i] & 255);
 
   return resultString;
 }
 
-AString UnicodeStringToMultiByte(const UString &srcString, UINT /* codePage */ )
+AString UnicodeStringToMultiByte(const UString &src, UINT /* codePage */ )
 {
 #ifdef ENV_HAVE_WCSTOMBS
+#if WCHAR_MAX > 0xffff
+  UString srcString(src);
+  for (int i = 0; i < srcString.Len(); i++) {
+    if ((0xd800 <= srcString[i] && srcString[i] <= 0xdbff) && ((i + 1) < srcString.Len()) &&
+        (0xdc00 <= srcString[i + 1] && srcString[i + 1] < 0xE000)) {
+      wchar_t c = (((srcString[i] - 0xd800) << 10) | (srcString[i + 1] - 0xdc00)) + 0x10000;
+      srcString.Delete(i, 2);
+      srcString.Insert(i, c);
+    }
+  }
+#else
+  const UString &srcString = src;
+#endif
+
   if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
   {
     AString resultString;
-    int numRequiredBytes = srcString.Length() * 6+1;
-    int numChars = wcstombs(resultString.GetBuffer(numRequiredBytes),srcString,numRequiredBytes);
+    int numRequiredBytes = srcString.Len() * 6+1;
+    int numChars = wcstombs(resultString.GetBuf(numRequiredBytes),srcString,numRequiredBytes);
     if (numChars >= 0) {
-      resultString.ReleaseBuffer(numChars);
+      resultString.ReleaseBuf_SetEnd(numChars);
       return resultString;
     }
   }
+#else
+  const UString &srcString = src;
 #endif
 
   AString resultString;
-  for (int i = 0; i < srcString.Length(); i++)
+  for (int i = 0; i < srcString.Len(); i++)
   {
     if (srcString[i] >= 256) resultString += '?';
     else                     resultString += char(srcString[i]);
@@ -179,3 +207,14 @@ AString UnicodeStringToMultiByte(const UString &srcString, UINT /* codePage */ )
 
 #endif /* LOCALE_IS_UTF8 */
 
+
+void MultiByteToUnicodeString2(UString &dest, const AString &srcString, UINT codePage)
+{
+  dest = MultiByteToUnicodeString(srcString,codePage);
+}
+
+void UnicodeStringToMultiByte2(AString &dest, const UString &srcString, UINT codePage)
+{
+  dest = UnicodeStringToMultiByte(srcString,codePage);
+}
+

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

@@ -3,15 +3,19 @@
 #ifndef __COMMON_STRING_CONVERT_H
 #define __COMMON_STRING_CONVERT_H
 
-#include "MyWindows.h"
 #include "MyString.h"
-#include "Types.h"
+#include "MyWindows.h"
 
 UString MultiByteToUnicodeString(const AString &srcString, UINT codePage = CP_ACP);
+
+// optimized versions that work faster for ASCII strings
+void MultiByteToUnicodeString2(UString &dest, const AString &srcString, UINT codePage = CP_ACP);
+// void UnicodeStringToMultiByte2(AString &dest, const UString &s, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
+void UnicodeStringToMultiByte2(AString &dest, const UString &srcString, UINT codePage);
+
 AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage, char defaultChar, bool &defaultCharWasUsed);
 AString UnicodeStringToMultiByte(const UString &srcString, UINT codePage = CP_ACP);
 
-
 inline const wchar_t* GetUnicodeString(const wchar_t* unicodeString)
   { return unicodeString; }
 inline const UString& GetUnicodeString(const UString &unicodeString)