fixed bug #1005296 - NSIS build error on Linux with g++ 3.4.0

- upgraded to the latest LZMA SDK


git-svn-id: https://svn.code.sf.net/p/nsis/code/NSIS/trunk@3637 212acab6-be3b-0410-9dea-997c60f758d6

Source/7zip/7zip/Common/InBuffer.cpp

@@ -1,19 +1,36 @@
 // InBuffer.cpp
 
-#include "stdafx.h"
+#include "StdAfx.h"
 
 #include "InBuffer.h"
 
-CInBuffer::CInBuffer(UINT32 bufferSize):
-  _bufferSize(bufferSize),
-  _bufferBase(0)
+#include "../../Common/Alloc.h"
+
+CInBuffer::CInBuffer(): 
+  _bufferBase(0), 
+  _bufferSize(0),
+  _buffer(0), 
+  _bufferLimit(0), 
+  _stream(0) 
+{}
+
+bool CInBuffer::Create(UInt32 bufferSize)
 {
-  _bufferBase = new BYTE[_bufferSize];
+  const UInt32 kMinBlockSize = 1;
+  if (bufferSize < kMinBlockSize)
+    bufferSize = kMinBlockSize;
+  if (_bufferBase != 0 && _bufferSize == bufferSize)
+    return true;
+  Free();
+  _bufferSize = bufferSize;
+  _bufferBase = (Byte *)::BigAlloc(bufferSize);
+  return (_bufferBase != 0);
 }
 
-CInBuffer::~CInBuffer()
+void CInBuffer::Free()
 {
-  delete []_bufferBase;
+  BigFree(_bufferBase);
+  _bufferBase = 0;
 }
 
 void CInBuffer::Init(ISequentialInStream *stream)
@@ -22,20 +39,31 @@ void CInBuffer::Init(ISequentialInStream *stream)
   _processedSize = 0;
   _buffer = _bufferBase;
   _bufferLimit = _buffer;
-  _streamWasExhausted = false;
+  _wasFinished = false;
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
 }
 
 bool CInBuffer::ReadBlock()
 {
-  if (_streamWasExhausted)
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    return false;
+  #endif
+  if (_wasFinished)
     return false;
   _processedSize += (_buffer - _bufferBase);
-  UINT32 numProcessedBytes;
+  UInt32 numProcessedBytes;
   HRESULT result = _stream->ReadPart(_bufferBase, _bufferSize, &numProcessedBytes);
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = result;
+  #else
   if (result != S_OK)
     throw CInBufferException(result);
+  #endif
   _buffer = _bufferBase;
   _bufferLimit = _buffer + numProcessedBytes;
-  _streamWasExhausted = (numProcessedBytes == 0);
-  return (!_streamWasExhausted);
+  _wasFinished = (numProcessedBytes == 0);
+  return (!_wasFinished);
 }

Source/7zip/7zip/Common/InBuffer.h

@@ -1,69 +1,74 @@
 // InBuffer.h
 
-// #pragma once
-
 #ifndef __INBUFFER_H
 #define __INBUFFER_H
 
 #include "../IStream.h"
 
+#ifndef _NO_EXCEPTIONS
 class CInBufferException
 {
 public:
   HRESULT ErrorCode;
   CInBufferException(HRESULT errorCode): ErrorCode(errorCode) {}
 };
+#endif
 
 class CInBuffer
 {
-  UINT64 _processedSize;
-  BYTE *_bufferBase;
-  UINT32 _bufferSize;
-  BYTE *_buffer;
-  BYTE *_bufferLimit;
+  UInt64 _processedSize;
+  Byte *_bufferBase;
+  UInt32 _bufferSize;
+  Byte *_buffer;
+  Byte *_bufferLimit;
   ISequentialInStream *_stream;
-  bool _streamWasExhausted;
+  bool _wasFinished;
 
   bool ReadBlock();
 
 public:
-  CInBuffer(UINT32 bufferSize = 0x100000);
-  ~CInBuffer();
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  CInBuffer();
+  ~CInBuffer() { Free(); }
+
+  bool Create(UInt32 bufferSize);
+  void Free();
   
   void Init(ISequentialInStream *stream);
-  /*
-  void ReleaseStream()
-    { _stream.Release(); }
-  */
+  // void ReleaseStream() { _stream.Release(); }
 
-  bool ReadByte(BYTE &b)
-    {
-      if(_buffer >= _bufferLimit)
-        if(!ReadBlock())
-          return false;
-      b = *_buffer++;
-      return true;
-    }
-  BYTE ReadByte()
-    {
-      if(_buffer >= _bufferLimit)
-        if(!ReadBlock())
-          return 0x0;
-      return *_buffer++;
-    }
-  void ReadBytes(void *data, UINT32 size, UINT32 &processedSize)
-    {
-      for(processedSize = 0; processedSize < size; processedSize++)
-        if (!ReadByte(((BYTE *)data)[processedSize]))
-          return;
-    }
-  bool ReadBytes(void *data, UINT32 size)
-    {
-      UINT32 processedSize;
-      ReadBytes(data, size, processedSize);
-      return (processedSize == size);
-    }
-  UINT64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }
+  bool ReadByte(Byte &b)
+  {
+    if(_buffer >= _bufferLimit)
+      if(!ReadBlock())
+        return false;
+    b = *_buffer++;
+    return true;
+  }
+  Byte ReadByte()
+  {
+    if(_buffer >= _bufferLimit)
+      if(!ReadBlock())
+        return 0xFF;
+    return *_buffer++;
+  }
+  void ReadBytes(void *data, UInt32 size, UInt32 &processedSize)
+  {
+    for(processedSize = 0; processedSize < size; processedSize++)
+      if (!ReadByte(((Byte *)data)[processedSize]))
+        return;
+  }
+  bool ReadBytes(void *data, UInt32 size)
+  {
+    UInt32 processedSize;
+    ReadBytes(data, size, processedSize);
+    return (processedSize == size);
+  }
+  UInt64 GetProcessedSize() const { return _processedSize + (_buffer - _bufferBase); }
+  bool WasFinished() const { return _wasFinished; }
 };
 
 #endif

Source/7zip/7zip/Common/OutBuffer.cpp

@@ -1,18 +1,28 @@
-// Stream/OutByte.cpp
+// OutByte.cpp
 
 #include "StdAfx.h"
 
 #include "OutBuffer.h"
 
-COutBuffer::COutBuffer(UINT32 bufferSize):
-  _bufferSize(bufferSize)
+#include "../../Common/Alloc.h"
+
+bool COutBuffer::Create(UInt32 bufferSize)
 {
-  _buffer = new BYTE[_bufferSize];
+  const UInt32 kMinBlockSize = 1;
+  if (bufferSize < kMinBlockSize)
+    bufferSize = kMinBlockSize;
+  if (_buffer != 0 && _bufferSize == bufferSize)
+    return true;
+  Free();
+  _bufferSize = bufferSize;
+  _buffer = (Byte *)::BigAlloc(bufferSize);
+  return (_buffer != 0);
 }
 
-COutBuffer::~COutBuffer()
+void COutBuffer::Free()
 {
-  delete []_buffer;
+  BigFree(_buffer);
+  _buffer = 0;
 }
 
 void COutBuffer::Init(ISequentialOutStream *stream)
@@ -20,21 +30,16 @@ void COutBuffer::Init(ISequentialOutStream *stream)
   _stream = stream;
   _processedSize = 0;
   _pos = 0;
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = S_OK;
+  #endif
 }
 
-/*
-void COutBuffer::ReleaseStream()
-{
-  _stream.Release();
-}
-*/
-
-
 HRESULT COutBuffer::Flush()
 {
   if (_pos == 0)
     return S_OK;
-  UINT32 processedSize;
+  UInt32 processedSize;
   HRESULT result = _stream->Write(_buffer, _pos, &processedSize);
   if (result != S_OK)
     return result;
@@ -47,7 +52,15 @@ HRESULT COutBuffer::Flush()
 
 void COutBuffer::WriteBlock()
 {
+  #ifdef _NO_EXCEPTIONS
+  if (ErrorCode != S_OK)
+    return;
+  #endif
   HRESULT result = Flush();
+  #ifdef _NO_EXCEPTIONS
+  ErrorCode = result;
+  #else
   if (result != S_OK)
     throw COutBufferException(result);
+  #endif
 }

Source/7zip/7zip/Common/OutBuffer.h

@@ -1,49 +1,69 @@
 // OutBuffer.h
 
-// #pragma once
-
 #ifndef __OUTBUFFER_H
 #define __OUTBUFFER_H
 
 #include "../IStream.h"
 
-class COutBufferException
+#ifndef _NO_EXCEPTIONS
+struct COutBufferException
 {
-public:
   HRESULT ErrorCode;
   COutBufferException(HRESULT errorCode): ErrorCode(errorCode) {}
 };
+#endif
 
 class COutBuffer
 {
-  BYTE *_buffer;
-  UINT32 _pos;
-  UINT32 _bufferSize;
+  Byte *_buffer;
+  UInt32 _pos;
+  UInt32 _bufferSize;
   ISequentialOutStream *_stream;
-  UINT64 _processedSize;
+  UInt64 _processedSize;
 
   void WriteBlock();
 public:
-  COutBuffer(UINT32 bufferSize = (1 << 20));
-  ~COutBuffer();
+  #ifdef _NO_EXCEPTIONS
+  HRESULT ErrorCode;
+  #endif
+
+  COutBuffer(): _buffer(0), _pos(0), _stream(0) {}
+  ~COutBuffer() { Free(); }
+  
+  bool Create(UInt32 bufferSize);
+  void Free();
 
   void Init(ISequentialOutStream *stream);
   HRESULT Flush();
-  // void ReleaseStream();
+  // void ReleaseStream(); {  _stream.Release(); }
 
-  void WriteByte(BYTE b)
+  /*
+  void *GetBuffer(UInt32 &sizeAvail)
+  {
+    sizeAvail = _bufferSize - _pos;
+    return _buffer + _pos;
+  }
+  void MovePos(UInt32 num)
+  {
+    _pos += num;
+    if(_pos >= _bufferSize)
+      WriteBlock();
+  }
+  */
+
+  void WriteByte(Byte b)
   {
     _buffer[_pos++] = b;
     if(_pos >= _bufferSize)
       WriteBlock();
   }
-  void WriteBytes(const void *data, UINT32 size)
+  void WriteBytes(const void *data, UInt32 size)
   {
-    for (UINT32 i = 0; i < size; i++)
-      WriteByte(((const BYTE *)data)[i]);
+    for (UInt32 i = 0; i < size; i++)
+      WriteByte(((const Byte *)data)[i]);
   }
 
-  UINT64 GetProcessedSize() const { return _processedSize + _pos; }
+  UInt64 GetProcessedSize() const { return _processedSize + _pos; }
 };
 
 #endif

Source/7zip/7zip/Common/StdAfx.h

@@ -1,12 +1,8 @@
-// stdafx.h
+// StdAfx.h
 
 #ifndef __STDAFX_H
 #define __STDAFX_H
 
-#ifdef _WIN32
-#  include <windows.h>
-#else
-#  include "../../../Platform.h"
-#endif
+#include "../../../Platform.h"
 
 #endif