firebird/firebird-mirror
firebird/firebird-mirror
8
0
Fork 1
mirror of https://github.com/FirebirdSQL/firebird.git synced 2025-01-22 21:23:04 +01:00
Code Issues

Replace FB_NOTHROW by noexcept and remove FB_THROW.

Browse Source
This commit is contained in:
Adriano dos Santos Fernandes 2021-05-31 08:55:26 -03:00
parent 01d4995fd7
commit 95cdf42c72
2 changed files with 94 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
src/common/classes/alloc.cpp
View File

@ -68,19 +68,19 @@
#define VALGRIND_FIX_IT // overrides suspicious valgrind behavior
#endif // USE_VALGRIND
void* operator new(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* operator new(size_t s ALLOC_PARAMS)
{
return MemoryPool::globalAlloc(s ALLOC_PASS_ARGS);
}
void* operator new[](size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* operator new[](size_t s ALLOC_PARAMS)
{
return MemoryPool::globalAlloc(s ALLOC_PASS_ARGS);
}
void operator delete(void* mem ALLOC_PARAMS) FB_NOTHROW
void operator delete(void* mem ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
void operator delete[](void* mem ALLOC_PARAMS) FB_NOTHROW
void operator delete[](void* mem ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
@ -109,7 +109,7 @@ static const int GUARD_BYTES = 0;
#endif
template <typename T>
T absVal(T n) FB_NOTHROW
T absVal(T n) noexcept
{
return n < 0 ? -n : n;
}
@ -160,7 +160,7 @@ struct FailedBlock
FailedBlock* failedList = NULL;
#endif
void corrupt(const char* text) FB_NOTHROW
void corrupt(const char* text) noexcept
{
#ifdef DEV_BUILD
fprintf(stderr, "%s\n", text);
@ -377,7 +377,7 @@ public:
#ifdef MEM_DEBUG
void print_contents(bool used, FILE* file, bool used_only,
const char* filter_path, const size_t filter_len) FB_NOTHROW
const char* filter_path, const size_t filter_len) noexcept
{
if (used || !used_only)
{
@ -406,7 +406,7 @@ public:
}
#endif
void validate(MemPool* p, StatInt& vUse) FB_NOTHROW
void validate(MemPool* p, StatInt& vUse) noexcept
{
if (p == pool && !isExtent())
vUse += getSize();
@ -461,7 +461,7 @@ protected:
}
public:
void validate(MemPool* pool, size_t hdr, StatInt& vMap, StatInt& vUse) FB_NOTHROW
void validate(MemPool* pool, size_t hdr, StatInt& vMap, StatInt& vUse) noexcept
{
if (length >= DEFAULT_ALLOCATION)
{
@ -526,7 +526,7 @@ public:
#ifdef MEM_DEBUG
void print_contents(FILE* file, MemPool* pool, bool used_only,
const char* filter_path, const size_t filter_len) FB_NOTHROW
const char* filter_path, const size_t filter_len) noexcept
{
UCHAR* m = ((UCHAR*) this) + hdrSize();
fprintf(file, "Small hunk %p: memory=[%p:%p) spaceRemaining=%" SIZEFORMAT " length=%" SIZEFORMAT "\n",
@ -598,7 +598,7 @@ public:
#ifdef MEM_DEBUG
void print_contents(FILE* file, MemPool* pool, bool used_only,
const char* filter_path, const size_t filter_len) FB_NOTHROW
const char* filter_path, const size_t filter_len) noexcept
{
UCHAR* m = ((UCHAR*) this) + hdrSize();
fprintf(file, "Medium hunk %p: memory=[%p:%p) spaceRemaining=%" SIZEFORMAT " length=%" SIZEFORMAT "\n",
@ -630,7 +630,7 @@ public:
#ifdef MEM_DEBUG
void print_contents(FILE* file, MemPool* pool, bool used_only,
const char* filter_path, const size_t filter_len) FB_NOTHROW
const char* filter_path, const size_t filter_len) noexcept
{
fprintf(file, "Big hunk %p: memory=%p length=%" SIZEFORMAT "\n",
this, block, length);
@ -1647,7 +1647,7 @@ public:
~FreeObjects();
FreeObjPtr allocateBlock(MemPool* pool, size_t from, size_t& size) FB_THROW (OOM_EXCEPTION)
FreeObjPtr allocateBlock(MemPool* pool, size_t from, size_t& size)
{
size_t full_size = size + (from ? 0 : ListBuilder::MEM_OVERHEAD);
if (full_size > Limits::TOP_LIMIT)
@ -1696,7 +1696,7 @@ public:
#ifdef MEM_DEBUG
void print_contents(FILE* file, MemPool* pool, bool used_only,
const char* filter_path, const size_t filter_len) FB_NOTHROW
const char* filter_path, const size_t filter_len) noexcept
{
for (Extent* ext = currentExtent; ext; ext = ext->next)
ext->print_contents(file, pool, used_only, filter_path, filter_len);
@ -1717,7 +1717,7 @@ private:
ListBuilder listBuilder;
Extent* currentExtent;
MemBlock* newBlock(MemPool* pool, unsigned slot) FB_THROW (OOM_EXCEPTION);
MemBlock* newBlock(MemPool* pool, unsigned slot);
};
@ -1799,26 +1799,26 @@ private:
};
#endif // VALIDATE_POOL
MemBlock* alloc(size_t from, size_t& length, bool flagRedirect) FB_THROW (OOM_EXCEPTION);
void releaseBlock(MemBlock *block, bool flagDecr) FB_NOTHROW;
MemBlock* alloc(size_t from, size_t& length, bool flagRedirect);
void releaseBlock(MemBlock *block, bool flagDecr) noexcept;
public:
void* allocate(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
MemBlock* allocate2(size_t from, size_t& size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
void* allocate(size_t size ALLOC_PARAMS);
MemBlock* allocate2(size_t from, size_t& size ALLOC_PARAMS);
private:
virtual void memoryIsExhausted(void) FB_THROW (OOM_EXCEPTION);
void* allocRaw(size_t length) FB_THROW (OOM_EXCEPTION);
static void releaseMemory(void* block, bool flagExtent) FB_NOTHROW;
static void releaseRaw(bool destroying, void *block, size_t size, bool use_cache = true) FB_NOTHROW;
void* getExtent(size_t from, size_t& to) FB_THROW (OOM_EXCEPTION);
virtual void memoryIsExhausted(void);
void* allocRaw(size_t length);
static void releaseMemory(void* block, bool flagExtent) noexcept;
static void releaseRaw(bool destroying, void *block, size_t size, bool use_cache = true) noexcept;
void* getExtent(size_t from, size_t& to);
public:
static void releaseExtent(bool destroying, void *block, size_t size, MemPool* pool) FB_NOTHROW;
static void releaseExtent(bool destroying, void *block, size_t size, MemPool* pool) noexcept;
// pass desired size, return actual extent size
template <class Extent>
void newExtent(size_t& size, Extent** linkedList) FB_THROW (OOM_EXCEPTION);
void newExtent(size_t& size, Extent** linkedList);
private:
#ifdef USE_VALGRIND
@ -1830,9 +1830,9 @@ private:
public:
static void deletePool(MemPool* pool);
static void globalFree(void* block) FB_NOTHROW;
static void globalFree(void* block) noexcept;
static void deallocate(void* block) FB_NOTHROW;
static void deallocate(void* block) noexcept;
bool validate(char* buf, FB_SIZE_T size);
// Create memory pool instance
@ -1840,7 +1840,7 @@ public:
// Set statistics group for pool. Usage counters will be decremented from
// previously set group and added to new
void setStatsGroup(MemoryStats& stats) FB_NOTHROW;
void setStatsGroup(MemoryStats& stats) noexcept;
// Initialize and finalize global memory pool
static MemPool* init()
@ -1893,25 +1893,25 @@ public:
}
// Statistics
void increment_usage(size_t size) FB_NOTHROW
void increment_usage(size_t size) noexcept
{
stats->increment_usage(size);
used_memory += size;
}
void decrement_usage(size_t size) FB_NOTHROW
void decrement_usage(size_t size) noexcept
{
stats->decrement_usage(size);
used_memory -= size;
}
void increment_mapping(size_t size) FB_NOTHROW
void increment_mapping(size_t size) noexcept
{
stats->increment_mapping(size);
mapped_memory += size;
}
void decrement_mapping(size_t size) FB_NOTHROW
void decrement_mapping(size_t size) noexcept
{
stats->decrement_mapping(size);
mapped_memory -= size;
@ -1919,9 +1919,9 @@ public:
#ifdef MEM_DEBUG
// Print out pool contents. This is debugging routine
void print_contents(FILE*, unsigned flags, const char* filter_path) FB_NOTHROW;
void print_contents(FILE*, unsigned flags, const char* filter_path) noexcept;
// The same routine, but more easily callable from the debugger
void print_contents(const char* filename, unsigned flags, const char* filter_path) FB_NOTHROW;
void print_contents(const char* filename, unsigned flags, const char* filter_path) noexcept;
private:
MemPool* next;
@ -1961,7 +1961,7 @@ void DoubleLinkedList::decrUsage(MemMediumHunk* hunk, MemPool* pool)
template <class ListBuilder, class Limits>
MemBlock* FreeObjects<ListBuilder, Limits>::newBlock(MemPool* pool, unsigned slot) FB_THROW (OOM_EXCEPTION)
MemBlock* FreeObjects<ListBuilder, Limits>::newBlock(MemPool* pool, unsigned slot)
{
size_t size = Limits::getSize(slot);
@ -2170,7 +2170,7 @@ MemPool::~MemPool(void)
}
template <class Extent>
void MemPool::newExtent(size_t& size, Extent** linkedList) FB_THROW(OOM_EXCEPTION)
void MemPool::newExtent(size_t& size, Extent** linkedList)
{
// No large enough block found. We need to extend the pool
void* memory = NULL;
@ -2214,7 +2214,7 @@ MemoryPool* MemoryPool::createPool(MemoryPool* parentPool, MemoryStats& stats)
return FB_NEW_POOL(*parentPool) MemoryPool(p);
}
void MemPool::setStatsGroup(MemoryStats& newStats) FB_NOTHROW
void MemPool::setStatsGroup(MemoryStats& newStats) noexcept
{
MutexLockGuard guard(mutex, "MemPool::setStatsGroup");
@ -2230,12 +2230,12 @@ void MemPool::setStatsGroup(MemoryStats& newStats) FB_NOTHROW
stats->increment_usage(sav_used_memory);
}
void MemoryPool::setStatsGroup(MemoryStats& newStats) FB_NOTHROW
void MemoryPool::setStatsGroup(MemoryStats& newStats) noexcept
{
pool->setStatsGroup(newStats);
}
MemBlock* MemPool::alloc(size_t from, size_t& length, bool flagRedirect) FB_THROW (OOM_EXCEPTION)
MemBlock* MemPool::alloc(size_t from, size_t& length, bool flagRedirect)
{
MutexEnsureUnlock guard(mutex, "MemPool::alloc");
guard.enter();
@ -2294,7 +2294,7 @@ MemBlock* MemPool::allocate2(size_t from, size_t& size
#ifdef DEBUG_GDS_ALLOC
, const char* fileName, int line
#endif
) FB_THROW (OOM_EXCEPTION)
)
{
size_t length = from ? size : ROUNDUP(size + VALGRIND_REDZONE, roundingSize) + GUARD_BYTES;
MemBlock* memory = alloc(from, length, true);
@ -2324,7 +2324,7 @@ MemBlock* MemPool::allocate2(size_t from, size_t& size
}
void* MemPool::allocate(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* MemPool::allocate(size_t size ALLOC_PARAMS)
{
#ifdef VALIDATE_POOL
MutexLockGuard guard(mutex, "MemPool::allocate");
@ -2339,7 +2339,7 @@ void* MemPool::allocate(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
}
void MemPool::releaseMemory(void* object, bool flagExtent) FB_NOTHROW
void MemPool::releaseMemory(void* object, bool flagExtent) noexcept
{
if (object)
{
@ -2403,7 +2403,7 @@ void MemPool::releaseMemory(void* object, bool flagExtent) FB_NOTHROW
}
}
void MemPool::releaseBlock(MemBlock* block, bool decrUsage) FB_NOTHROW
void MemPool::releaseBlock(MemBlock* block, bool decrUsage) noexcept
{
if (block->pool != this)
corrupt("bad block released");
@ -2464,12 +2464,12 @@ void MemPool::releaseBlock(MemBlock* block, bool decrUsage) FB_NOTHROW
releaseRaw(pool_destroying, hunk, hunk->length, false);
}
void MemPool::memoryIsExhausted(void) FB_THROW (OOM_EXCEPTION)
void MemPool::memoryIsExhausted(void)
{
Firebird::BadAlloc::raise();
}
void* MemPool::allocRaw(size_t size) FB_THROW (OOM_EXCEPTION)
void* MemPool::allocRaw(size_t size)
{
#ifndef USE_VALGRIND
if (size == DEFAULT_ALLOCATION)
@ -2549,7 +2549,7 @@ void* MemPool::allocRaw(size_t size) FB_THROW (OOM_EXCEPTION)
}
void* MemPool::getExtent(size_t from, size_t& to) FB_THROW(OOM_EXCEPTION) // pass desired minimum size, return actual extent size
void* MemPool::getExtent(size_t from, size_t& to) // pass desired minimum size, return actual extent size
{
#ifdef VALIDATE_POOL
MutexLockGuard guard(mutex, "MemPool::getExtent");
@ -2560,7 +2560,7 @@ void* MemPool::getExtent(size_t from, size_t& to) FB_THROW(OOM_EXCEPTION) // pa
}
void MemPool::releaseExtent(bool destroying, void* block, size_t size, MemPool* pool) FB_NOTHROW
void MemPool::releaseExtent(bool destroying, void* block, size_t size, MemPool* pool) noexcept
{
if (size < DEFAULT_ALLOCATION)
releaseMemory(block, true);
@ -2573,7 +2573,7 @@ void MemPool::releaseExtent(bool destroying, void* block, size_t size, MemPool*
}
void MemPool::releaseRaw(bool destroying, void* block, size_t size, bool use_cache) FB_NOTHROW
void MemPool::releaseRaw(bool destroying, void* block, size_t size, bool use_cache) noexcept
{
#ifndef USE_VALGRIND
if (use_cache && (size == DEFAULT_ALLOCATION))
@ -2666,19 +2666,19 @@ void MemPool::releaseRaw(bool destroying, void* block, size_t size, bool use_cac
}
}
void MemPool::globalFree(void* block) FB_NOTHROW
void MemPool::globalFree(void* block) noexcept
{
deallocate(block);
}
void* MemoryPool::calloc(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* MemoryPool::calloc(size_t size ALLOC_PARAMS)
{
void* block = allocate(size ALLOC_PASS_ARGS);
memset(block, 0, size);
return block;
}
void MemPool::deallocate(void* block) FB_NOTHROW
void MemPool::deallocate(void* block) noexcept
{
releaseMemory(block, false);
}
@ -2720,7 +2720,7 @@ bool MemPool::validate(char* buf, FB_SIZE_T size)
}
#ifdef MEM_DEBUG
void MemPool::print_contents(const char* filename, unsigned flags, const char* filter_path) FB_NOTHROW
void MemPool::print_contents(const char* filename, unsigned flags, const char* filter_path) noexcept
{
FILE* out = os_utils::fopen(filename, "w");
if (!out)
@ -2731,7 +2731,7 @@ void MemPool::print_contents(const char* filename, unsigned flags, const char* f
}
// This member function can't be const because there are calls to the mutex.
void MemPool::print_contents(FILE* file, unsigned flags, const char* filter_path) FB_NOTHROW
void MemPool::print_contents(FILE* file, unsigned flags, const char* filter_path) noexcept
{
bool used_only = flags & MemoryPool::PRINT_USED_ONLY;
@ -2818,7 +2818,7 @@ MemoryPool& AutoStorage::getAutoMemoryPool()
}
#ifdef LIBC_CALLS_NEW
void* MemoryPool::globalAlloc(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* MemoryPool::globalAlloc(size_t s ALLOC_PARAMS)
{
if (!defaultMemoryManager)
{
@ -2831,17 +2831,17 @@ void* MemoryPool::globalAlloc(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
}
#endif // LIBC_CALLS_NEW
void MemoryPool::globalFree(void* block) FB_NOTHROW
void MemoryPool::globalFree(void* block) noexcept
{
MemPool::globalFree(block);
}
void* MemoryPool::allocate(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
void* MemoryPool::allocate(size_t size ALLOC_PARAMS)
{
return pool->allocate(size ALLOC_PASS_ARGS);
}
void MemoryPool::deallocate(void* block) FB_NOTHROW
void MemoryPool::deallocate(void* block) noexcept
{
pool->deallocate(block);
}
@ -2870,14 +2870,14 @@ void MemoryPool::deletePool(MemoryPool* pool)
delete pool;
}
void MemoryPool::print_contents(FILE* file, unsigned flags, const char* filter_path) FB_NOTHROW
void MemoryPool::print_contents(FILE* file, unsigned flags, const char* filter_path) noexcept
{
#ifdef MEM_DEBUG
pool->print_contents(file, flags, filter_path);
#endif
}
void MemoryPool::print_contents(const char* filename, unsigned flags, const char* filter_path) FB_NOTHROW
void MemoryPool::print_contents(const char* filename, unsigned flags, const char* filter_path) noexcept
{
#ifdef MEM_DEBUG
pool->print_contents(filename, flags, filter_path);
@ -2950,21 +2950,21 @@ void AutoStorage::ProbeStack() const
// in a case when we actually need "new" only with file/line information
// this version should be also present as a pair for "delete".
#ifdef DEBUG_GDS_ALLOC
void* operator new(size_t s) FB_THROW (OOM_EXCEPTION)
void* operator new(size_t s)
{
return MemoryPool::globalAlloc(s ALLOC_ARGS);
}
void* operator new[](size_t s) FB_THROW (OOM_EXCEPTION)
void* operator new[](size_t s)
{
return MemoryPool::globalAlloc(s ALLOC_ARGS);
}
void operator delete(void* mem) FB_NOTHROW
void operator delete(void* mem) noexcept
{
MemoryPool::globalFree(mem);
}
void operator delete[](void* mem) FB_NOTHROW
void operator delete[](void* mem) noexcept
{
MemoryPool::globalFree(mem);
}

74
src/common/classes/alloc.h
View File

@ -58,20 +58,6 @@
#include <memory.h>
#define OOM_EXCEPTION std::bad_alloc
#if __cplusplus >= 201103L
#define FB_NO_THROW_SPECIFIER
#endif
#ifdef FB_NO_THROW_SPECIFIER
#define FB_THROW(x)
#define FB_NOTHROW noexcept
#else
#define FB_THROW(x) throw(x)
#define FB_NOTHROW throw()
#endif
#ifdef DEBUG_GDS_ALLOC
#define FB_NEW new(__FILE__, __LINE__)
#define FB_NEW_POOL(pool) new(pool, __FILE__, __LINE__)
@ -106,10 +92,10 @@ public:
~MemoryStats()
{}
size_t getCurrentUsage() const FB_NOTHROW { return mst_usage.value(); }
size_t getMaximumUsage() const FB_NOTHROW { return mst_max_usage; }
size_t getCurrentMapping() const FB_NOTHROW { return mst_mapped.value(); }
size_t getMaximumMapping() const FB_NOTHROW { return mst_max_mapped; }
size_t getCurrentUsage() const noexcept { return mst_usage.value(); }
size_t getMaximumUsage() const noexcept { return mst_max_usage; }
size_t getCurrentMapping() const noexcept { return mst_mapped.value(); }
size_t getMaximumMapping() const noexcept { return mst_max_mapped; }
private:
// Forbid copying/assignment
@ -131,7 +117,7 @@ private:
size_t mst_max_mapped;
// These methods are thread-safe due to usage of atomic counters only
void increment_usage(size_t size) FB_NOTHROW
void increment_usage(size_t size) noexcept
{
for (MemoryStats* statistics = this; statistics; statistics = statistics->mst_parent)
{
@ -141,7 +127,7 @@ private:
}
}
void decrement_usage(size_t size) FB_NOTHROW
void decrement_usage(size_t size) noexcept
{
for (MemoryStats* statistics = this; statistics; statistics = statistics->mst_parent)
{
@ -149,7 +135,7 @@ private:
}
}
void increment_mapping(size_t size) FB_NOTHROW
void increment_mapping(size_t size) noexcept
{
for (MemoryStats* statistics = this; statistics; statistics = statistics->mst_parent)
{
@ -159,7 +145,7 @@ private:
}
}
void decrement_mapping(size_t size) FB_NOTHROW
void decrement_mapping(size_t size) noexcept
{
for (MemoryStats* statistics = this; statistics; statistics = statistics->mst_parent)
{
@ -205,21 +191,21 @@ public:
#define ALLOC_PASS_ARGS
#endif // DEBUG_GDS_ALLOC
void* calloc(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
void* calloc(size_t size ALLOC_PARAMS);
#ifdef LIBC_CALLS_NEW
static void* globalAlloc(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
static void* globalAlloc(size_t s ALLOC_PARAMS);
#else
static void* globalAlloc(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
static void* globalAlloc(size_t s ALLOC_PARAMS)
{
return defaultMemoryManager->allocate(s ALLOC_PASS_ARGS);
}
#endif // LIBC_CALLS_NEW
void* allocate(size_t size ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
void* allocate(size_t size ALLOC_PARAMS);
static void globalFree(void* mem) FB_NOTHROW;
void deallocate(void* mem) FB_NOTHROW;
static void globalFree(void* mem) noexcept;
void deallocate(void* mem) noexcept;
// Set context pool for current thread of execution
static MemoryPool* setContextPool(MemoryPool* newPool);
@ -229,7 +215,7 @@ public:
// Set statistics group for pool. Usage counters will be decremented from
// previously set group and added to new
void setStatsGroup(MemoryStats& stats) FB_NOTHROW;
void setStatsGroup(MemoryStats& stats) noexcept;
// Initialize and finalize global memory pool
static void init();
@ -241,9 +227,9 @@ public:
// Print out pool contents. This is debugging routine
static const unsigned PRINT_USED_ONLY = 0x01;
static const unsigned PRINT_RECURSIVE = 0x02;
void print_contents(FILE*, unsigned flags = 0, const char* filter_path = 0) FB_NOTHROW;
void print_contents(FILE*, unsigned flags = 0, const char* filter_path = 0) noexcept;
// The same routine, but more easily callable from the debugger
void print_contents(const char* filename, unsigned flags = 0, const char* filter_path = 0) FB_NOTHROW;
void print_contents(const char* filename, unsigned flags = 0, const char* filter_path = 0) noexcept;
public:
struct Finalizer
@ -298,7 +284,7 @@ private:
} // namespace Firebird
static inline Firebird::MemoryPool* getDefaultMemoryPool() FB_NOTHROW
static inline Firebird::MemoryPool* getDefaultMemoryPool() noexcept
{
fb_assert(Firebird::MemoryPool::defaultMemoryManager);
return Firebird::MemoryPool::defaultMemoryManager;
@ -355,36 +341,36 @@ private:
using Firebird::MemoryPool;
// operators new and delete
extern void* operator new(size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
extern void* operator new[](size_t s ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION);
extern void operator delete(void* mem ALLOC_PARAMS) FB_NOTHROW;
extern void operator delete[](void* mem ALLOC_PARAMS) FB_NOTHROW;
extern void* operator new(size_t s ALLOC_PARAMS);
extern void* operator new[](size_t s ALLOC_PARAMS);
extern void operator delete(void* mem ALLOC_PARAMS) noexcept;
extern void operator delete[](void* mem ALLOC_PARAMS) noexcept;
inline void* operator new(size_t s, Firebird::MemoryPool& pool ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
inline void* operator new(size_t s, Firebird::MemoryPool& pool ALLOC_PARAMS)
{
return pool.allocate(s ALLOC_PASS_ARGS);
}
inline void* operator new[](size_t s, Firebird::MemoryPool& pool ALLOC_PARAMS) FB_THROW (OOM_EXCEPTION)
inline void* operator new[](size_t s, Firebird::MemoryPool& pool ALLOC_PARAMS)
{
return pool.allocate(s ALLOC_PASS_ARGS);
}
inline void operator delete(void* mem, Firebird::MemoryPool& pool ALLOC_PARAMS) FB_NOTHROW
inline void operator delete(void* mem, Firebird::MemoryPool& pool ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
inline void operator delete[](void* mem, Firebird::MemoryPool& pool ALLOC_PARAMS) FB_NOTHROW
inline void operator delete[](void* mem, Firebird::MemoryPool& pool ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
#if __cplusplus >= 201402L
inline void operator delete(void* mem, std::size_t s ALLOC_PARAMS) FB_NOTHROW
inline void operator delete(void* mem, std::size_t s ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
inline void operator delete[](void* mem, std::size_t s ALLOC_PARAMS) FB_NOTHROW
inline void operator delete[](void* mem, std::size_t s ALLOC_PARAMS) noexcept
{
MemoryPool::globalFree(mem);
}
@ -392,8 +378,8 @@ inline void operator delete[](void* mem, std::size_t s ALLOC_PARAMS) FB_NOTHROW
#ifdef DEBUG_GDS_ALLOC
extern void operator delete(void* mem) FB_NOTHROW;
extern void operator delete[](void* mem) FB_NOTHROW;
extern void operator delete(void* mem) noexcept;
extern void operator delete[](void* mem) noexcept;
#endif // DEBUG_GDS_ALLOC