xevion/easy7zip
1
0
Fork 0
mirror of https://github.com/Xevion/easy7zip.git synced 2025-12-08 12:07:03 -06:00
Code Issues Packages Projects Releases Wiki Activity

Update to 7-Zip Version 21.02

Browse Source
This commit is contained in:
Tino Reichardt
2021-05-13 16:39:14 +02:00
parent 3724ecfedc
commit 48fa49f76c
620 changed files with 35032 additions and 10925 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
CPP/7zip/Common/MemBlocks.cpp
View File

@@ -7,21 +7,26 @@
#include "MemBlocks.h"
#include "StreamUtils.h"
bool CMemBlockManager::AllocateSpace(size_t numBlocks)
bool CMemBlockManager::AllocateSpace_bool(size_t numBlocks)
{
FreeSpace();
if (_blockSize < sizeof(void *) || numBlocks < 1)
if (numBlocks == 0)
{
return true;
// return false;
}
if (_blockSize < sizeof(void *))
return false;
size_t totalSize = numBlocks * _blockSize;
const size_t totalSize = numBlocks * _blockSize;
if (totalSize / _blockSize != numBlocks)
return false;
_data = ::MidAlloc(totalSize);
if (_data == 0)
if (!_data)
return false;
Byte *p = (Byte *)_data;
for (size_t i = 0; i + 1 < numBlocks; i++, p += _blockSize)
*(Byte **)p = (p + _blockSize);
*(Byte **)p = 0;
*(Byte **)(void *)p = (p + _blockSize);
*(Byte **)(void *)p = NULL;
_headFree = _data;
return true;
}
@@ -35,41 +40,64 @@ void CMemBlockManager::FreeSpace()
void *CMemBlockManager::AllocateBlock()
{
if (_headFree == 0)
return 0;
void *p = _headFree;
_headFree = *(void **)_headFree;
if (p)
_headFree = *(void **)p;
return p;
}
void CMemBlockManager::FreeBlock(void *p)
{
if (p == 0)
if (!p)
return;
*(void **)p = _headFree;
_headFree = p;
}
// #include <stdio.h>
HRes CMemBlockManagerMt::AllocateSpace(size_t numBlocks, size_t numNoLockBlocks)
{
if (numNoLockBlocks > numBlocks)
return E_INVALIDARG;
if (!CMemBlockManager::AllocateSpace(numBlocks))
const size_t numLockBlocks = numBlocks - numNoLockBlocks;
UInt32 maxCount = (UInt32)numLockBlocks;
if (maxCount != numLockBlocks)
return E_OUTOFMEMORY;
if (!CMemBlockManager::AllocateSpace_bool(numBlocks))
return E_OUTOFMEMORY;
size_t numLockBlocks = numBlocks - numNoLockBlocks;
Semaphore.Close();
return Semaphore.Create((LONG)numLockBlocks, (LONG)numLockBlocks);
// we need (maxCount = 1), if we want to create non-use empty Semaphore
if (maxCount == 0)
maxCount = 1;
// printf("\n Synchro.Create() \n");
WRes wres;
#ifndef _WIN32
wres = Synchro.Create();
if (wres != 0)
return HRESULT_FROM_WIN32(wres);
wres = Semaphore.Create(&Synchro, (UInt32)numLockBlocks, maxCount);
#else
wres = Semaphore.Create((UInt32)numLockBlocks, maxCount);
#endif
return HRESULT_FROM_WIN32(wres);
}
HRes CMemBlockManagerMt::AllocateSpaceAlways(size_t desiredNumberOfBlocks, size_t numNoLockBlocks)
{
// desiredNumberOfBlocks = 0; // for debug
if (numNoLockBlocks > desiredNumberOfBlocks)
return E_INVALIDARG;
for (;;)
{
if (AllocateSpace(desiredNumberOfBlocks, numNoLockBlocks) == 0)
return 0;
// if (desiredNumberOfBlocks == 0) return E_OUTOFMEMORY;
HRes hres = AllocateSpace(desiredNumberOfBlocks, numNoLockBlocks);
if (hres != E_OUTOFMEMORY)
return hres;
if (desiredNumberOfBlocks == numNoLockBlocks)
return E_OUTOFMEMORY;
desiredNumberOfBlocks = numNoLockBlocks + ((desiredNumberOfBlocks - numNoLockBlocks) >> 1);
@@ -91,7 +119,7 @@ void *CMemBlockManagerMt::AllocateBlock()
void CMemBlockManagerMt::FreeBlock(void *p, bool lockMode)
{
if (p == 0)
if (!p)
return;
{
NWindows::NSynchronization::CCriticalSectionLock lock(_criticalSection);
@@ -101,6 +129,8 @@ void CMemBlockManagerMt::FreeBlock(void *p, bool lockMode)
Semaphore.Release();
}
void CMemBlocks::Free(CMemBlockManagerMt *manager)
{
while (Blocks.Size() > 0)
@@ -122,9 +152,9 @@ HRESULT CMemBlocks::WriteToStream(size_t blockSize, ISequentialOutStream *outStr
UInt64 totalSize = TotalSize;
for (unsigned blockIndex = 0; totalSize > 0; blockIndex++)
{
UInt32 curSize = (UInt32)blockSize;
if (totalSize < curSize)
curSize = (UInt32)totalSize;
size_t curSize = blockSize;
if (curSize > totalSize)
curSize = (size_t)totalSize;
if (blockIndex >= Blocks.Size())
return E_FAIL;
RINOK(WriteStream(outStream, Blocks[blockIndex], curSize));
@@ -134,10 +164,10 @@ HRESULT CMemBlocks::WriteToStream(size_t blockSize, ISequentialOutStream *outStr
}
void CMemLockBlocks::FreeBlock(int index, CMemBlockManagerMt *memManager)
void CMemLockBlocks::FreeBlock(unsigned index, CMemBlockManagerMt *memManager)
{
memManager->FreeBlock(Blocks[index], LockMode);
Blocks[index] = 0;
Blocks[index] = NULL;
}
void CMemLockBlocks::Free(CMemBlockManagerMt *memManager)
@@ -150,6 +180,7 @@ void CMemLockBlocks::Free(CMemBlockManagerMt *memManager)
TotalSize = 0;
}
/*
HRes CMemLockBlocks::SwitchToNoLockMode(CMemBlockManagerMt *memManager)
{
if (LockMode)
@@ -162,13 +193,14 @@ HRes CMemLockBlocks::SwitchToNoLockMode(CMemBlockManagerMt *memManager)
}
return 0;
}
*/
void CMemLockBlocks::Detach(CMemLockBlocks &blocks, CMemBlockManagerMt *memManager)
{
blocks.Free(memManager);
blocks.LockMode = LockMode;
UInt64 totalSize = 0;
size_t blockSize = memManager->GetBlockSize();
const size_t blockSize = memManager->GetBlockSize();
FOR_VECTOR (i, Blocks)
{
if (totalSize < TotalSize)