firebird/firebird-4.0.0.2496-noexcept.patch

From a999f35f0fad27798fdc88a3f5cdf2e3e9041594 Mon Sep 17 00:00:00 2001
From: Adriano dos Santos Fernandes <adrianosf@gmail.com>
Date: Mon, 31 May 2021 08:55:26 -0300
Subject: [PATCH] Replace FB_NOTHROW by noexcept and remove FB_THROW.

---
 src/common/classes/alloc.cpp | 128 +++++++++++++++++------------------
 src/common/classes/alloc.h   |  74 ++++++++------------
 2 files changed, 94 insertions(+), 108 deletions(-)

diff --git a/src/common/classes/alloc.cpp b/src/common/classes/alloc.cpp
index 1bd6ad4f09d..ee91ab89df8 100644
--- a/src/common/classes/alloc.cpp
+++ b/src/common/classes/alloc.cpp
@@ -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 @@ class MemHeader
 
 #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 @@ class MemHeader
 	}
 #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 @@ class MemBaseHunk
 	}
 
 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 @@ class MemSmallHunk : public MemBaseHunk<MemSmallHunk>
 
 #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 @@ class MemMediumHunk : public MemBaseHunk<MemMediumHunk>
 
 #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 @@ class MemBigHunk
 
 #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 @@ class FreeObjects
 
 	~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 @@ class FreeObjects
 
 #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 @@ class FreeObjects
 	ListBuilder listBuilder;
 	Extent* currentExtent;
 
-	MemBlock* newBlock(MemPool* pool, unsigned slot) FB_THROW (OOM_EXCEPTION);
+	MemBlock* newBlock(MemPool* pool, unsigned slot);
 };
 
 
@@ -1799,26 +1799,26 @@ class MemPool
 	};
 #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 @@ class MemPool
 
 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 @@ class MemPool
 
 	// 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 @@ class MemPool
 	}
 
 	// 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 @@ class MemPool
 
 #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);
 }
diff --git a/src/common/classes/alloc.h b/src/common/classes/alloc.h
index 65f9afbb8a9..44d9e0ea462 100644
--- a/src/common/classes/alloc.h
+++ b/src/common/classes/alloc.h
@@ -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 @@ class MemoryStats
 	~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 @@ class MemoryStats
 	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 @@ class MemoryStats
 		}
 	}
 
-	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 @@ class MemoryStats
 		}
 	}
 
-	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 @@ class MemoryStats
 		}
 	}
 
-	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 @@ class MemoryPool
 #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 @@ class MemoryPool
 
 	// 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 @@ class MemoryPool
 	// 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 @@ class MemoryPool
 
 } // 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 @@ class SubsystemContextPoolHolder : public ContextPoolHolder
 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