From 60d3dd98a44230c21803c1606552ee098ed9fa7c Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 21 Feb 2024 21:05:14 +0100 Subject: Convert remaining BOOL to bool --- indra/llcorehttp/bufferarray.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/llcorehttp/bufferarray.cpp') diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp index 8d2e7c6a63..f70a163cef 100644 --- a/indra/llcorehttp/bufferarray.cpp +++ b/indra/llcorehttp/bufferarray.cpp @@ -149,7 +149,7 @@ size_t BufferArray::append(const void * src, size_t len) } catch (std::bad_alloc&) { - LLMemory::logMemoryInfo(TRUE); + LLMemory::logMemoryInfo(true); //output possible call stacks to log file. LLError::LLCallStacks::print(); -- cgit v1.2.3 From e2e37cced861b98de8c1a7c9c0d3a50d2d90e433 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 22 May 2024 21:25:21 +0200 Subject: Fix line endlings --- indra/llcorehttp/bufferarray.cpp | 736 +++++++++++++++++++-------------------- 1 file changed, 368 insertions(+), 368 deletions(-) (limited to 'indra/llcorehttp/bufferarray.cpp') diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp index c35f44c2c9..6b33661d8f 100644 --- a/indra/llcorehttp/bufferarray.cpp +++ b/indra/llcorehttp/bufferarray.cpp @@ -1,368 +1,368 @@ -/** - * @file bufferarray.cpp - * @brief Implements the BufferArray scatter/gather buffer - * - * $LicenseInfo:firstyear=2012&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2012, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - -#include "bufferarray.h" -#include "llexception.h" -#include "llmemory.h" - - -// BufferArray is a list of chunks, each a BufferArray::Block, of contiguous -// data presented as a single array. Chunks are at least BufferArray::BLOCK_ALLOC_SIZE -// in length and can be larger. Any chunk may be partially filled or even -// empty. -// -// The BufferArray itself is sharable as a RefCounted entity. As shared -// reads don't work with the concept of a current position/seek value, -// none is kept with the object. Instead, the read and write operations -// all take position arguments. Single write/shared read isn't supported -// directly and any such attempts have to be serialized outside of this -// implementation. - -namespace LLCore -{ - - -// ================================== -// BufferArray::Block Declaration -// ================================== - -class BufferArray::Block -{ -public: - ~Block(); - - void operator delete(void *); - void operator delete(void *, size_t len); - -protected: - Block(size_t len); - - Block(const Block &); // Not defined - void operator=(const Block &); // Not defined - - // Allocate the block with the additional space for the - // buffered data at the end of the object. - void * operator new(size_t len, size_t addl_len); - -public: - // Only public entry to get a block. - static Block * alloc(size_t len); - -public: - size_t mUsed; - size_t mAlloced; - - // *NOTE: Must be last member of the object. We'll - // overallocate as requested via operator new and index - // into the array at will. - char mData[1]; -}; - - -// ================================== -// BufferArray Definitions -// ================================== - - -#if ! LL_WINDOWS -const size_t BufferArray::BLOCK_ALLOC_SIZE; -#endif // ! LL_WINDOWS - -BufferArray::BufferArray() - : LLCoreInt::RefCounted(true), - mLen(0) -{} - - -BufferArray::~BufferArray() -{ - for (container_t::iterator it(mBlocks.begin()); - it != mBlocks.end(); - ++it) - { - delete *it; - *it = NULL; - } - mBlocks.clear(); -} - - -size_t BufferArray::append(const void * src, size_t len) -{ - const size_t ret(len); - const char * c_src(static_cast(src)); - - // First, try to copy into the last block - if (len && ! mBlocks.empty()) - { - Block & last(*mBlocks.back()); - if (last.mUsed < last.mAlloced) - { - // Some will fit... - const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed))); - - memcpy(&last.mData[last.mUsed], c_src, copy_len); - last.mUsed += copy_len; - llassert_always(last.mUsed <= last.mAlloced); - mLen += copy_len; - c_src += copy_len; - len -= copy_len; - } - } - - // Then get new blocks as needed - while (len) - { - const size_t copy_len((std::min)(len, BLOCK_ALLOC_SIZE)); - - if (mBlocks.size() >= mBlocks.capacity()) - { - mBlocks.reserve(mBlocks.size() + 5); - } - Block * block; - try - { - block = Block::alloc(BLOCK_ALLOC_SIZE); - } - catch (std::bad_alloc&) - { - LLMemory::logMemoryInfo(true); - - //output possible call stacks to log file. - LLError::LLCallStacks::print(); - - LL_WARNS() << "Bad memory allocation in thrown by Block::alloc in read!" << LL_ENDL; - break; - } - memcpy(block->mData, c_src, copy_len); - block->mUsed = copy_len; - llassert_always(block->mUsed <= block->mAlloced); - mBlocks.push_back(block); - mLen += copy_len; - c_src += copy_len; - len -= copy_len; - } - return ret - len; -} - - -void * BufferArray::appendBufferAlloc(size_t len) -{ - // If someone asks for zero-length, we give them a valid pointer. - if (mBlocks.size() >= mBlocks.capacity()) - { - mBlocks.reserve(mBlocks.size() + 5); - } - Block * block = Block::alloc((std::max)(BLOCK_ALLOC_SIZE, len)); - block->mUsed = len; - mBlocks.push_back(block); - mLen += len; - return block->mData; -} - - -size_t BufferArray::read(size_t pos, void * dst, size_t len) -{ - char * c_dst(static_cast(dst)); - - if (pos >= mLen) - return 0; - size_t len_limit(mLen - pos); - len = (std::min)(len, len_limit); - if (0 == len) - return 0; - - size_t result(0), offset(0); - const auto block_limit(mBlocks.size()); - int block_start(findBlock(pos, &offset)); - if (block_start < 0) - return 0; - - do - { - Block & block(*mBlocks[block_start]); - size_t block_limit(block.mUsed - offset); - size_t block_len((std::min)(block_limit, len)); - - memcpy(c_dst, &block.mData[offset], block_len); - result += block_len; - len -= block_len; - c_dst += block_len; - offset = 0; - ++block_start; - } - while (len && block_start < block_limit); - - return result; -} - - -size_t BufferArray::write(size_t pos, const void * src, size_t len) -{ - const char * c_src(static_cast(src)); - - if (pos > mLen || 0 == len) - return 0; - - size_t result(0), offset(0); - const auto block_limit(mBlocks.size()); - int block_start(findBlock(pos, &offset)); - - if (block_start >= 0) - { - // Some or all of the write will be on top of - // existing data. - do - { - Block & block(*mBlocks[block_start]); - size_t block_limit(block.mUsed - offset); - size_t block_len((std::min)(block_limit, len)); - - memcpy(&block.mData[offset], c_src, block_len); - result += block_len; - c_src += block_len; - len -= block_len; - offset = 0; - ++block_start; - } - while (len && block_start < block_limit); - } - - // Something left, see if it will fit in the free - // space of the last block. - if (len && ! mBlocks.empty()) - { - Block & last(*mBlocks.back()); - if (last.mUsed < last.mAlloced) - { - // Some will fit... - const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed))); - - memcpy(&last.mData[last.mUsed], c_src, copy_len); - last.mUsed += copy_len; - result += copy_len; - llassert_always(last.mUsed <= last.mAlloced); - mLen += copy_len; - c_src += copy_len; - len -= copy_len; - } - } - - if (len) - { - // Some or all of the remaining write data will - // be an append. - result += append(c_src, len); - } - - return result; -} - - -int BufferArray::findBlock(size_t pos, size_t * ret_offset) -{ - *ret_offset = 0; - if (pos >= mLen) - return -1; // Doesn't exist - - const int block_limit(narrow(mBlocks.size())); - for (int i(0); i < block_limit; ++i) - { - if (pos < mBlocks[i]->mUsed) - { - *ret_offset = pos; - return i; - } - pos -= mBlocks[i]->mUsed; - } - - // Shouldn't get here but... - return -1; -} - - -bool BufferArray::getBlockStartEnd(int block, const char ** start, const char ** end) -{ - if (block < 0 || block >= mBlocks.size()) - { - return false; - } - - const Block & b(*mBlocks[block]); - *start = &b.mData[0]; - *end = &b.mData[b.mUsed]; - return true; -} - - -// ================================== -// BufferArray::Block Definitions -// ================================== - - -BufferArray::Block::Block(size_t len) - : mUsed(0), - mAlloced(len) -{ - memset(mData, 0, len); -} - - -BufferArray::Block::~Block() -{ - mUsed = 0; - mAlloced = 0; -} - - -void * BufferArray::Block::operator new(size_t len, size_t addl_len) -{ - void * mem = new char[len + addl_len + sizeof(void *)]; - return mem; -} - - -void BufferArray::Block::operator delete(void * mem) -{ - char * cmem = static_cast(mem); - delete [] cmem; -} - - -void BufferArray::Block::operator delete(void * mem, size_t) -{ - operator delete(mem); -} - - -BufferArray::Block * BufferArray::Block::alloc(size_t len) -{ - Block * block = new (len) Block(len); - return block; -} - - -} // end namespace LLCore +/** + * @file bufferarray.cpp + * @brief Implements the BufferArray scatter/gather buffer + * + * $LicenseInfo:firstyear=2012&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2012, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#include "bufferarray.h" +#include "llexception.h" +#include "llmemory.h" + + +// BufferArray is a list of chunks, each a BufferArray::Block, of contiguous +// data presented as a single array. Chunks are at least BufferArray::BLOCK_ALLOC_SIZE +// in length and can be larger. Any chunk may be partially filled or even +// empty. +// +// The BufferArray itself is sharable as a RefCounted entity. As shared +// reads don't work with the concept of a current position/seek value, +// none is kept with the object. Instead, the read and write operations +// all take position arguments. Single write/shared read isn't supported +// directly and any such attempts have to be serialized outside of this +// implementation. + +namespace LLCore +{ + + +// ================================== +// BufferArray::Block Declaration +// ================================== + +class BufferArray::Block +{ +public: + ~Block(); + + void operator delete(void *); + void operator delete(void *, size_t len); + +protected: + Block(size_t len); + + Block(const Block &); // Not defined + void operator=(const Block &); // Not defined + + // Allocate the block with the additional space for the + // buffered data at the end of the object. + void * operator new(size_t len, size_t addl_len); + +public: + // Only public entry to get a block. + static Block * alloc(size_t len); + +public: + size_t mUsed; + size_t mAlloced; + + // *NOTE: Must be last member of the object. We'll + // overallocate as requested via operator new and index + // into the array at will. + char mData[1]; +}; + + +// ================================== +// BufferArray Definitions +// ================================== + + +#if ! LL_WINDOWS +const size_t BufferArray::BLOCK_ALLOC_SIZE; +#endif // ! LL_WINDOWS + +BufferArray::BufferArray() + : LLCoreInt::RefCounted(true), + mLen(0) +{} + + +BufferArray::~BufferArray() +{ + for (container_t::iterator it(mBlocks.begin()); + it != mBlocks.end(); + ++it) + { + delete *it; + *it = NULL; + } + mBlocks.clear(); +} + + +size_t BufferArray::append(const void * src, size_t len) +{ + const size_t ret(len); + const char * c_src(static_cast(src)); + + // First, try to copy into the last block + if (len && ! mBlocks.empty()) + { + Block & last(*mBlocks.back()); + if (last.mUsed < last.mAlloced) + { + // Some will fit... + const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed))); + + memcpy(&last.mData[last.mUsed], c_src, copy_len); + last.mUsed += copy_len; + llassert_always(last.mUsed <= last.mAlloced); + mLen += copy_len; + c_src += copy_len; + len -= copy_len; + } + } + + // Then get new blocks as needed + while (len) + { + const size_t copy_len((std::min)(len, BLOCK_ALLOC_SIZE)); + + if (mBlocks.size() >= mBlocks.capacity()) + { + mBlocks.reserve(mBlocks.size() + 5); + } + Block * block; + try + { + block = Block::alloc(BLOCK_ALLOC_SIZE); + } + catch (std::bad_alloc&) + { + LLMemory::logMemoryInfo(true); + + //output possible call stacks to log file. + LLError::LLCallStacks::print(); + + LL_WARNS() << "Bad memory allocation in thrown by Block::alloc in read!" << LL_ENDL; + break; + } + memcpy(block->mData, c_src, copy_len); + block->mUsed = copy_len; + llassert_always(block->mUsed <= block->mAlloced); + mBlocks.push_back(block); + mLen += copy_len; + c_src += copy_len; + len -= copy_len; + } + return ret - len; +} + + +void * BufferArray::appendBufferAlloc(size_t len) +{ + // If someone asks for zero-length, we give them a valid pointer. + if (mBlocks.size() >= mBlocks.capacity()) + { + mBlocks.reserve(mBlocks.size() + 5); + } + Block * block = Block::alloc((std::max)(BLOCK_ALLOC_SIZE, len)); + block->mUsed = len; + mBlocks.push_back(block); + mLen += len; + return block->mData; +} + + +size_t BufferArray::read(size_t pos, void * dst, size_t len) +{ + char * c_dst(static_cast(dst)); + + if (pos >= mLen) + return 0; + size_t len_limit(mLen - pos); + len = (std::min)(len, len_limit); + if (0 == len) + return 0; + + size_t result(0), offset(0); + const auto block_limit(mBlocks.size()); + int block_start(findBlock(pos, &offset)); + if (block_start < 0) + return 0; + + do + { + Block & block(*mBlocks[block_start]); + size_t block_limit(block.mUsed - offset); + size_t block_len((std::min)(block_limit, len)); + + memcpy(c_dst, &block.mData[offset], block_len); + result += block_len; + len -= block_len; + c_dst += block_len; + offset = 0; + ++block_start; + } + while (len && block_start < block_limit); + + return result; +} + + +size_t BufferArray::write(size_t pos, const void * src, size_t len) +{ + const char * c_src(static_cast(src)); + + if (pos > mLen || 0 == len) + return 0; + + size_t result(0), offset(0); + const auto block_limit(mBlocks.size()); + int block_start(findBlock(pos, &offset)); + + if (block_start >= 0) + { + // Some or all of the write will be on top of + // existing data. + do + { + Block & block(*mBlocks[block_start]); + size_t block_limit(block.mUsed - offset); + size_t block_len((std::min)(block_limit, len)); + + memcpy(&block.mData[offset], c_src, block_len); + result += block_len; + c_src += block_len; + len -= block_len; + offset = 0; + ++block_start; + } + while (len && block_start < block_limit); + } + + // Something left, see if it will fit in the free + // space of the last block. + if (len && ! mBlocks.empty()) + { + Block & last(*mBlocks.back()); + if (last.mUsed < last.mAlloced) + { + // Some will fit... + const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed))); + + memcpy(&last.mData[last.mUsed], c_src, copy_len); + last.mUsed += copy_len; + result += copy_len; + llassert_always(last.mUsed <= last.mAlloced); + mLen += copy_len; + c_src += copy_len; + len -= copy_len; + } + } + + if (len) + { + // Some or all of the remaining write data will + // be an append. + result += append(c_src, len); + } + + return result; +} + + +int BufferArray::findBlock(size_t pos, size_t * ret_offset) +{ + *ret_offset = 0; + if (pos >= mLen) + return -1; // Doesn't exist + + const int block_limit(narrow(mBlocks.size())); + for (int i(0); i < block_limit; ++i) + { + if (pos < mBlocks[i]->mUsed) + { + *ret_offset = pos; + return i; + } + pos -= mBlocks[i]->mUsed; + } + + // Shouldn't get here but... + return -1; +} + + +bool BufferArray::getBlockStartEnd(int block, const char ** start, const char ** end) +{ + if (block < 0 || block >= mBlocks.size()) + { + return false; + } + + const Block & b(*mBlocks[block]); + *start = &b.mData[0]; + *end = &b.mData[b.mUsed]; + return true; +} + + +// ================================== +// BufferArray::Block Definitions +// ================================== + + +BufferArray::Block::Block(size_t len) + : mUsed(0), + mAlloced(len) +{ + memset(mData, 0, len); +} + + +BufferArray::Block::~Block() +{ + mUsed = 0; + mAlloced = 0; +} + + +void * BufferArray::Block::operator new(size_t len, size_t addl_len) +{ + void * mem = new char[len + addl_len + sizeof(void *)]; + return mem; +} + + +void BufferArray::Block::operator delete(void * mem) +{ + char * cmem = static_cast(mem); + delete [] cmem; +} + + +void BufferArray::Block::operator delete(void * mem, size_t) +{ + operator delete(mem); +} + + +BufferArray::Block * BufferArray::Block::alloc(size_t len) +{ + Block * block = new (len) Block(len); + return block; +} + + +} // end namespace LLCore -- cgit v1.2.3