Revert "noexcept + const in MetaName"

mrotteveel · mrotteveel · commit 95b77a491f5a · 2025-08-05T10:15:24.000+02:00
This reverts commit d2caf98.
diff --git a/src/jrd/MetaName.cpp b/src/jrd/MetaName.cpp
@@ -29,7 +29,6 @@
 #include "firebird.h"
 
 #include <stdarg.h>
-#include <algorithm>
 
 #include "../jrd/MetaName.h"
 #include "../common/classes/MetaString.h"
@@ -43,7 +42,7 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const
 	if (s)
 	{
 		adjustLength(s, len);
-		const FB_SIZE_T x = std::min(length(), len);
+		FB_SIZE_T x = length() < len ? length() : len;
 		int rc = memcmp(c_str(), s, x);
 		if (rc)
 		{
@@ -56,11 +55,11 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const
 	return length() - len;
 }
 
-void MetaName::adjustLength(const char* const s, FB_SIZE_T& len) noexcept
+void MetaName::adjustLength(const char* const s, FB_SIZE_T& len)
 {
-	fb_assert(s);
 	if (len > MAX_SQL_IDENTIFIER_LEN)
 	{
+		fb_assert(s);
 #ifdef DEV_BUILD
 		for (FB_SIZE_T i = MAX_SQL_IDENTIFIER_LEN; i < len; ++i)
 			fb_assert(s[i] == '\0' || s[i] == ' ');
@@ -82,7 +81,7 @@ void MetaName::printf(const char* format, ...)
 	char data[MAX_SQL_IDENTIFIER_LEN + 1];
 	va_list params;
 	va_start(params, format);
-	int len = vsnprintf(data, MAX_SQL_IDENTIFIER_LEN, format, params);
+	int len = VSNPRINTF(data, MAX_SQL_IDENTIFIER_LEN, format, params);
 	va_end(params);
 
 	if (len < 0 || FB_SIZE_T(len) > MAX_SQL_IDENTIFIER_LEN)
@@ -106,7 +105,7 @@ FB_SIZE_T MetaName::copyTo(char* to, FB_SIZE_T toSize) const
 	return toSize;
 }
 
-MetaName::operator Firebird::MetaString() const noexcept
+MetaName::operator Firebird::MetaString() const
 {
 	return Firebird::MetaString(c_str(), length());
 }
@@ -126,7 +125,7 @@ void MetaName::test()
 #if defined(DEV_BUILD) || GROW_DEBUG > 0
 	if (word)
 	{
-		const Dictionary::Word* checkWord = get(word->c_str(), word->length());
+		Dictionary::Word* checkWord = get(word->c_str(), word->length());
 		fb_assert(checkWord == word);
 #ifndef DEV_BUILD
 		if (word != checkWord)
@@ -136,15 +135,17 @@ void MetaName::test()
 #endif
 }
 
+const char* MetaName::EMPTY = "";
+
 #if GROW_DEBUG > 1
-static constexpr unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,
+static const unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,
 										12000, 14000, 16000, 18000, 20000,
 										22000, 24000, 26000, 28000, 30000,
 										32000, 34000, 36000, 38000, 40000,
 										42000, 44000, 46000, 48000, 50000,
 										52000, 54000, 56000, 58000, 60000};
 #else
-static constexpr unsigned int hashSize[] = { 10007, 100003, 1000003 };
+static const unsigned int hashSize[] = { 10007, 100003, 1000003 };
 #endif
 
 Dictionary::Dictionary(MemoryPool& p)
@@ -186,7 +187,7 @@ Dictionary::HashTable::HashTable(MemoryPool& p, unsigned lvl)
 		table[n].store(nullptr, std::memory_order_relaxed);
 }
 
-unsigned Dictionary::HashTable::getMaxLevel() noexcept
+unsigned Dictionary::HashTable::getMaxLevel()
 {
 	return FB_NELEM(hashSize) - 1;
 }
@@ -222,7 +223,7 @@ Dictionary::TableData* Dictionary::HashTable::getEntryByHash(const char* s, FB_S
 	return &table[h];
 }
 
-bool Dictionary::checkConsistency(const Dictionary::HashTable* oldValue) noexcept
+bool Dictionary::checkConsistency(Dictionary::HashTable* oldValue)
 {
 	return oldValue->level == nextLevel.load();
 }
@@ -290,7 +291,7 @@ Dictionary::Word* Dictionary::get(const char* s, FB_SIZE_T len)
 					{
 						segment = FB_NEW_POOL(getPool()) Segment;
 						++segCount;
-						const unsigned lvl = nextLevel.load();
+						unsigned lvl = nextLevel.load();
 						if (lvl < HashTable::getMaxLevel() &&
 							segCount * Segment::getWordCapacity() > hashSize[lvl])
 						{
@@ -365,7 +366,7 @@ void Dictionary::growHash()
 
 	// move one level up size of hash table
 	HashTable* tab = hashTable.load();
-	const unsigned lvl = ++nextLevel;
+	unsigned lvl = ++nextLevel;
 	fb_assert(lvl == tab->level + 1);
 	fb_assert(lvl <= HashTable::getMaxLevel());
 
@@ -420,7 +421,7 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor
 		return t;
 
 	// may be we already have that word in new table
-	const FB_SIZE_T len = (*checkWordPtr)->length();
+	FB_SIZE_T len = (*checkWordPtr)->length();
 	const char* s = (*checkWordPtr)->c_str();
 	Word* word = t->getEntryByHash(s, len)->load();
 	while (word)
@@ -440,25 +441,25 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor
 	return t;
 }
 
-Dictionary::Segment::Segment() noexcept
+Dictionary::Segment::Segment()
 {
 	position.store(0, std::memory_order_relaxed);
 }
 
-constexpr unsigned Dictionary::Segment::getWordCapacity() noexcept
+unsigned Dictionary::Segment::getWordCapacity()
 {
-	constexpr unsigned AVERAGE_BYTES_LEN = 16;
+	const unsigned AVERAGE_BYTES_LEN = 16;
 	return SEG_BUFFER_SIZE / getWordLength(AVERAGE_BYTES_LEN);
 }
 
-constexpr unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len) noexcept
+unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len)
 {
 	// calculate length in sizeof(Word*)
 	len += 2;
-	return 1 + (len / sizeof(Word*)) + ((len % sizeof(Word*)) ? 1 : 0);
+	return 1 + (len / sizeof(Word*)) + (len % sizeof(Word*) ? 1 : 0);
 }
 
-Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept
+Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR)
 {
 	len = getWordLength(len);
 
@@ -469,7 +470,7 @@ Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_P
 	for(;;)
 	{
 		// calculate and check new position
-		const unsigned newPos = oldPos + len;
+		unsigned newPos = oldPos + len;
 		if (newPos >= SEG_BUFFER_SIZE)
 			break;
 
diff --git a/src/jrd/MetaName.h b/src/jrd/MetaName.h
@@ -73,12 +73,12 @@ class Dictionary : public Firebird::PermanentStorage
 		char text[1];
 
 	public:
-		const char* c_str() const noexcept
+		const char* c_str() const
 		{
 			return text;
 		}
 
-		FB_SIZE_T length() const noexcept
+		FB_SIZE_T length() const
 		{
 			return textLen;
 		}
@@ -102,31 +102,31 @@ class Dictionary : public Firebird::PermanentStorage
 	public:
 		HashTable(MemoryPool& p, unsigned lvl);
 		Dictionary::TableData* getEntryByHash(const char* s, FB_SIZE_T len);
-		static unsigned getMaxLevel() noexcept;
+		static unsigned getMaxLevel();
 
 		const unsigned level;
 		TableData* table;
 	};
 	std::atomic<HashTable*> hashTable;
 	std::atomic<unsigned> nextLevel;
 
-	bool checkConsistency(const HashTable* oldValue) noexcept;
+	bool checkConsistency(HashTable* oldValue);
 	HashTable* waitForMutex(Word** checkWordPtr = nullptr);
 
 	class Segment
 	{
 	public:
-		Segment() noexcept;
-		Word* getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept;
-		static constexpr unsigned getWordCapacity() noexcept;
+		Segment();
+		Word* getSpace(FB_SIZE_T l DIC_STAT_SEGMENT_PAR);
+		static unsigned getWordCapacity();
 
 	private:
-		static constexpr unsigned getWordLength(FB_SIZE_T len) noexcept;
+		static unsigned getWordLength(FB_SIZE_T len);
 
 #if GROW_DEBUG > 1
-		static constexpr unsigned SEG_BUFFER_SIZE = 256;		// size in sizeof(pointer)
+		static const unsigned SEG_BUFFER_SIZE = 256;		// size in sizeof(pointer)
 #else
-		static constexpr unsigned SEG_BUFFER_SIZE = 16384;		// size in sizeof(pointer)
+		static const unsigned SEG_BUFFER_SIZE = 16384;		// size in sizeof(pointer)
 #endif
 		void* buffer[SEG_BUFFER_SIZE];
 		std::atomic<unsigned> position;
@@ -141,7 +141,7 @@ class MetaName
 {
 private:
 	Dictionary::Word* word;
-	static constexpr const char* EMPTY = "";
+	static const char* EMPTY;
 
 	void test();
 	Dictionary::Word* get(const char* s, FB_SIZE_T l);
@@ -152,7 +152,7 @@ class MetaName
 	}
 
 public:
-	MetaName() noexcept
+	MetaName()
 		: word(nullptr)
 	{ }
 
@@ -177,7 +177,7 @@ class MetaName
 	{ }
 
 
-	explicit MetaName(MemoryPool&) noexcept
+	explicit MetaName(MemoryPool&)
 		: word(nullptr)
 	{ }
 
@@ -233,43 +233,43 @@ class MetaName
 
 	MetaName& operator=(const Firebird::MetaString& s);
 
-	FB_SIZE_T length() const noexcept
+	FB_SIZE_T length() const
 	{
 		return word ? word->length() : 0;
 	}
 
-	const char* c_str() const noexcept
+	const char* c_str() const
 	{
 		return word ? word->c_str() : EMPTY;
 	}
 
-	const char* nullStr() const noexcept
+	const char* nullStr() const
 	{
 		return word ? word->c_str() : nullptr;
 	}
 
-	bool isEmpty() const noexcept
+	bool isEmpty() const
 	{
 		return !word;
 	}
 
-	bool hasData() const noexcept
+	bool hasData() const
 	{
 		return word;
 	}
 
-	char operator[](unsigned n) const noexcept
+	char operator[](unsigned n) const
 	{
 		fb_assert(n < length());
 		return word->c_str()[n];
 	}
 
-	const char* begin() const noexcept
+	const char* begin() const
 	{
 		return word ? word->c_str() : EMPTY;
 	}
 
-	const char* end() const noexcept
+	const char* end() const
 	{
 		return word ? &word->c_str()[length()] : EMPTY;
 	}
@@ -354,22 +354,22 @@ class MetaName
 		return compare(m) >  0;
 	}
 
-	bool operator==(const MetaName& m) const noexcept
+	bool operator==(const MetaName& m) const
 	{
 		return word == m.word;
 	}
 
-	bool operator!=(const MetaName& m) const noexcept
+	bool operator!=(const MetaName& m) const
 	{
 		return word != m.word;
 	}
 
 	void printf(const char*, ...);
 	FB_SIZE_T copyTo(char* to, FB_SIZE_T toSize) const;
-	operator Firebird::MetaString() const noexcept;
+	operator Firebird::MetaString() const;
 
 protected:
-	static void adjustLength(const char* const s, FB_SIZE_T& l) noexcept;
+	static void adjustLength(const char* const s, FB_SIZE_T& l);
 };
 
 typedef Firebird::Pair<Firebird::Full<MetaName, MetaName> > MetaNamePair;

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,6 @@`
`29`	`29`	`#include "firebird.h"`
`30`	`30`
`31`	`31`	`#include <stdarg.h>`
`32`		`-#include <algorithm>`
`33`	`32`
`34`	`33`	`#include "../jrd/MetaName.h"`
`35`	`34`	`#include "../common/classes/MetaString.h"`
`@@ -43,7 +42,7 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const`
`43`	`42`	`if (s)`
`44`	`43`	`{`
`45`	`44`	`adjustLength(s, len);`
`46`		`- const FB_SIZE_T x = std::min(length(), len);`
	`45`	`+ FB_SIZE_T x = length() < len ? length() : len;`
`47`	`46`	`int rc = memcmp(c_str(), s, x);`
`48`	`47`	`if (rc)`
`49`	`48`	`{`
`@@ -56,11 +55,11 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const`
`56`	`55`	`return length() - len;`
`57`	`56`	`}`
`58`	`57`
`59`		`-void MetaName::adjustLength(const char* const s, FB_SIZE_T& len) noexcept`
	`58`	`+void MetaName::adjustLength(const char* const s, FB_SIZE_T& len)`
`60`	`59`	`{`
`61`		`- fb_assert(s);`
`62`	`60`	`if (len > MAX_SQL_IDENTIFIER_LEN)`
`63`	`61`	`{`
	`62`	`+ fb_assert(s);`
`64`	`63`	`#ifdef DEV_BUILD`
`65`	`64`	`for (FB_SIZE_T i = MAX_SQL_IDENTIFIER_LEN; i < len; ++i)`
`66`	`65`	`fb_assert(s[i] == '\0' \|\| s[i] == ' ');`
`@@ -82,7 +81,7 @@ void MetaName::printf(const char* format, ...)`
`82`	`81`	`char data[MAX_SQL_IDENTIFIER_LEN + 1];`
`83`	`82`	`va_list params;`
`84`	`83`	`va_start(params, format);`
`85`		`- int len = vsnprintf(data, MAX_SQL_IDENTIFIER_LEN, format, params);`
	`84`	`+ int len = VSNPRINTF(data, MAX_SQL_IDENTIFIER_LEN, format, params);`
`86`	`85`	`va_end(params);`
`87`	`86`
`88`	`87`	`if (len < 0 \|\| FB_SIZE_T(len) > MAX_SQL_IDENTIFIER_LEN)`
`@@ -106,7 +105,7 @@ FB_SIZE_T MetaName::copyTo(char* to, FB_SIZE_T toSize) const`
`106`	`105`	`return toSize;`
`107`	`106`	`}`
`108`	`107`
`109`		`-MetaName::operator Firebird::MetaString() const noexcept`
	`108`	`+MetaName::operator Firebird::MetaString() const`
`110`	`109`	`{`
`111`	`110`	`return Firebird::MetaString(c_str(), length());`
`112`	`111`	`}`
`@@ -126,7 +125,7 @@ void MetaName::test()`
`126`	`125`	`#if defined(DEV_BUILD) \|\| GROW_DEBUG > 0`
`127`	`126`	`if (word)`
`128`	`127`	`{`
`129`		`- const Dictionary::Word* checkWord = get(word->c_str(), word->length());`
	`128`	`+ Dictionary::Word* checkWord = get(word->c_str(), word->length());`
`130`	`129`	`fb_assert(checkWord == word);`
`131`	`130`	`#ifndef DEV_BUILD`
`132`	`131`	`if (word != checkWord)`
`@@ -136,15 +135,17 @@ void MetaName::test()`
`136`	`135`	`#endif`
`137`	`136`	`}`
`138`	`137`
	`138`	`+const char* MetaName::EMPTY = "";`
	`139`	`+`
`139`	`140`	`#if GROW_DEBUG > 1`
`140`		`-static constexpr unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,`
	`141`	`+static const unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,`
`141`	`142`	`12000, 14000, 16000, 18000, 20000,`
`142`	`143`	`22000, 24000, 26000, 28000, 30000,`
`143`	`144`	`32000, 34000, 36000, 38000, 40000,`
`144`	`145`	`42000, 44000, 46000, 48000, 50000,`
`145`	`146`	`52000, 54000, 56000, 58000, 60000};`
`146`	`147`	`#else`
`147`		`-static constexpr unsigned int hashSize[] = { 10007, 100003, 1000003 };`
	`148`	`+static const unsigned int hashSize[] = { 10007, 100003, 1000003 };`
`148`	`149`	`#endif`
`149`	`150`
`150`	`151`	`Dictionary::Dictionary(MemoryPool& p)`
`@@ -186,7 +187,7 @@ Dictionary::HashTable::HashTable(MemoryPool& p, unsigned lvl)`
`186`	`187`	`table[n].store(nullptr, std::memory_order_relaxed);`
`187`	`188`	`}`
`188`	`189`
`189`		`-unsigned Dictionary::HashTable::getMaxLevel() noexcept`
	`190`	`+unsigned Dictionary::HashTable::getMaxLevel()`
`190`	`191`	`{`
`191`	`192`	`return FB_NELEM(hashSize) - 1;`
`192`	`193`	`}`
`@@ -222,7 +223,7 @@ Dictionary::TableData* Dictionary::HashTable::getEntryByHash(const char* s, FB_S`
`222`	`223`	`return &table[h];`
`223`	`224`	`}`
`224`	`225`
`225`		`-bool Dictionary::checkConsistency(const Dictionary::HashTable* oldValue) noexcept`
	`226`	`+bool Dictionary::checkConsistency(Dictionary::HashTable* oldValue)`
`226`	`227`	`{`
`227`	`228`	`return oldValue->level == nextLevel.load();`
`228`	`229`	`}`
`@@ -290,7 +291,7 @@ Dictionary::Word* Dictionary::get(const char* s, FB_SIZE_T len)`
`290`	`291`	`{`
`291`	`292`	`segment = FB_NEW_POOL(getPool()) Segment;`
`292`	`293`	`++segCount;`
`293`		`- const unsigned lvl = nextLevel.load();`
	`294`	`+ unsigned lvl = nextLevel.load();`
`294`	`295`	`if (lvl < HashTable::getMaxLevel() &&`
`295`	`296`	`segCount * Segment::getWordCapacity() > hashSize[lvl])`
`296`	`297`	`{`
`@@ -365,7 +366,7 @@ void Dictionary::growHash()`
`365`	`366`
`366`	`367`	`// move one level up size of hash table`
`367`	`368`	`HashTable* tab = hashTable.load();`
`368`		`- const unsigned lvl = ++nextLevel;`
	`369`	`+ unsigned lvl = ++nextLevel;`
`369`	`370`	`fb_assert(lvl == tab->level + 1);`
`370`	`371`	`fb_assert(lvl <= HashTable::getMaxLevel());`
`371`	`372`
`@@ -420,7 +421,7 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor`
`420`	`421`	`return t;`
`421`	`422`
`422`	`423`	`// may be we already have that word in new table`
`423`		`- const FB_SIZE_T len = (*checkWordPtr)->length();`
	`424`	`+ FB_SIZE_T len = (*checkWordPtr)->length();`
`424`	`425`	`const char* s = (*checkWordPtr)->c_str();`
`425`	`426`	`Word* word = t->getEntryByHash(s, len)->load();`
`426`	`427`	`while (word)`
`@@ -440,25 +441,25 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor`
`440`	`441`	`return t;`
`441`	`442`	`}`
`442`	`443`
`443`		`-Dictionary::Segment::Segment() noexcept`
	`444`	`+Dictionary::Segment::Segment()`
`444`	`445`	`{`
`445`	`446`	`position.store(0, std::memory_order_relaxed);`
`446`	`447`	`}`
`447`	`448`
`448`		`-constexpr unsigned Dictionary::Segment::getWordCapacity() noexcept`
	`449`	`+unsigned Dictionary::Segment::getWordCapacity()`
`449`	`450`	`{`
`450`		`- constexpr unsigned AVERAGE_BYTES_LEN = 16;`
	`451`	`+ const unsigned AVERAGE_BYTES_LEN = 16;`
`451`	`452`	`return SEG_BUFFER_SIZE / getWordLength(AVERAGE_BYTES_LEN);`
`452`	`453`	`}`
`453`	`454`
`454`		`-constexpr unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len) noexcept`
	`455`	`+unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len)`
`455`	`456`	`{`
`456`	`457`	`// calculate length in sizeof(Word*)`
`457`	`458`	`len += 2;`
`458`		`- return 1 + (len / sizeof(Word)) + ((len % sizeof(Word)) ? 1 : 0);`
	`459`	`+ return 1 + (len / sizeof(Word)) + (len % sizeof(Word) ? 1 : 0);`
`459`	`460`	`}`
`460`	`461`
`461`		`-Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept`
	`462`	`+Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR)`
`462`	`463`	`{`
`463`	`464`	`len = getWordLength(len);`
`464`	`465`
`@@ -469,7 +470,7 @@ Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_P`
`469`	`470`	`for(;;)`
`470`	`471`	`{`
`471`	`472`	`// calculate and check new position`
`472`		`- const unsigned newPos = oldPos + len;`
	`473`	`+ unsigned newPos = oldPos + len;`
`473`	`474`	`if (newPos >= SEG_BUFFER_SIZE)`
`474`	`475`	`break;`
`475`	`476`
Original file line number	Diff line number	Diff line change
`@@ -73,12 +73,12 @@ class Dictionary : public Firebird::PermanentStorage`
`73`	`73`	`char text[1];`
`74`	`74`
`75`	`75`	`public:`
`76`		`- const char* c_str() const noexcept`
	`76`	`+ const char* c_str() const`
`77`	`77`	`{`
`78`	`78`	`return text;`
`79`	`79`	`}`
`80`	`80`
`81`		`- FB_SIZE_T length() const noexcept`
	`81`	`+ FB_SIZE_T length() const`
`82`	`82`	`{`
`83`	`83`	`return textLen;`
`84`	`84`	`}`
`@@ -102,31 +102,31 @@ class Dictionary : public Firebird::PermanentStorage`
`102`	`102`	`public:`
`103`	`103`	`HashTable(MemoryPool& p, unsigned lvl);`
`104`	`104`	`Dictionary::TableData* getEntryByHash(const char* s, FB_SIZE_T len);`
`105`		`- static unsigned getMaxLevel() noexcept;`
	`105`	`+ static unsigned getMaxLevel();`
`106`	`106`
`107`	`107`	`const unsigned level;`
`108`	`108`	`TableData* table;`
`109`	`109`	`};`
`110`	`110`	`std::atomic<HashTable*> hashTable;`
`111`	`111`	`std::atomic<unsigned> nextLevel;`
`112`	`112`
`113`		`- bool checkConsistency(const HashTable* oldValue) noexcept;`
	`113`	`+ bool checkConsistency(HashTable* oldValue);`
`114`	`114`	`HashTable* waitForMutex(Word** checkWordPtr = nullptr);`
`115`	`115`
`116`	`116`	`class Segment`
`117`	`117`	`{`
`118`	`118`	`public:`
`119`		`- Segment() noexcept;`
`120`		`- Word* getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept;`
`121`		`- static constexpr unsigned getWordCapacity() noexcept;`
	`119`	`+ Segment();`
	`120`	`+ Word* getSpace(FB_SIZE_T l DIC_STAT_SEGMENT_PAR);`
	`121`	`+ static unsigned getWordCapacity();`
`122`	`122`
`123`	`123`	`private:`
`124`		`- static constexpr unsigned getWordLength(FB_SIZE_T len) noexcept;`
	`124`	`+ static unsigned getWordLength(FB_SIZE_T len);`
`125`	`125`
`126`	`126`	`#if GROW_DEBUG > 1`
`127`		`- static constexpr unsigned SEG_BUFFER_SIZE = 256; // size in sizeof(pointer)`
	`127`	`+ static const unsigned SEG_BUFFER_SIZE = 256; // size in sizeof(pointer)`
`128`	`128`	`#else`
`129`		`- static constexpr unsigned SEG_BUFFER_SIZE = 16384; // size in sizeof(pointer)`
	`129`	`+ static const unsigned SEG_BUFFER_SIZE = 16384; // size in sizeof(pointer)`
`130`	`130`	`#endif`
`131`	`131`	`void* buffer[SEG_BUFFER_SIZE];`
`132`	`132`	`std::atomic<unsigned> position;`
`@@ -141,7 +141,7 @@ class MetaName`
`141`	`141`	`{`
`142`	`142`	`private:`
`143`	`143`	`Dictionary::Word* word;`
`144`		`- static constexpr const char* EMPTY = "";`
	`144`	`+ static const char* EMPTY;`
`145`	`145`
`146`	`146`	`void test();`
`147`	`147`	`Dictionary::Word* get(const char* s, FB_SIZE_T l);`
`@@ -152,7 +152,7 @@ class MetaName`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`public:`
`155`		`- MetaName() noexcept`
	`155`	`+ MetaName()`
`156`	`156`	`: word(nullptr)`
`157`	`157`	`{ }`
`158`	`158`
`@@ -177,7 +177,7 @@ class MetaName`
`177`	`177`	`{ }`
`178`	`178`
`179`	`179`
`180`		`- explicit MetaName(MemoryPool&) noexcept`
	`180`	`+ explicit MetaName(MemoryPool&)`
`181`	`181`	`: word(nullptr)`
`182`	`182`	`{ }`
`183`	`183`
`@@ -233,43 +233,43 @@ class MetaName`
`233`	`233`
`234`	`234`	`MetaName& operator=(const Firebird::MetaString& s);`
`235`	`235`
`236`		`- FB_SIZE_T length() const noexcept`
	`236`	`+ FB_SIZE_T length() const`
`237`	`237`	`{`
`238`	`238`	`return word ? word->length() : 0;`
`239`	`239`	`}`
`240`	`240`
`241`		`- const char* c_str() const noexcept`
	`241`	`+ const char* c_str() const`
`242`	`242`	`{`
`243`	`243`	`return word ? word->c_str() : EMPTY;`
`244`	`244`	`}`
`245`	`245`
`246`		`- const char* nullStr() const noexcept`
	`246`	`+ const char* nullStr() const`
`247`	`247`	`{`
`248`	`248`	`return word ? word->c_str() : nullptr;`
`249`	`249`	`}`
`250`	`250`
`251`		`- bool isEmpty() const noexcept`
	`251`	`+ bool isEmpty() const`
`252`	`252`	`{`
`253`	`253`	`return !word;`
`254`	`254`	`}`
`255`	`255`
`256`		`- bool hasData() const noexcept`
	`256`	`+ bool hasData() const`
`257`	`257`	`{`
`258`	`258`	`return word;`
`259`	`259`	`}`
`260`	`260`
`261`		`- char operator[](unsigned n) const noexcept`
	`261`	`+ char operator[](unsigned n) const`
`262`	`262`	`{`
`263`	`263`	`fb_assert(n < length());`
`264`	`264`	`return word->c_str()[n];`
`265`	`265`	`}`
`266`	`266`
`267`		`- const char* begin() const noexcept`
	`267`	`+ const char* begin() const`
`268`	`268`	`{`
`269`	`269`	`return word ? word->c_str() : EMPTY;`
`270`	`270`	`}`
`271`	`271`
`272`		`- const char* end() const noexcept`
	`272`	`+ const char* end() const`
`273`	`273`	`{`
`274`	`274`	`return word ? &word->c_str()[length()] : EMPTY;`
`275`	`275`	`}`
`@@ -354,22 +354,22 @@ class MetaName`
`354`	`354`	`return compare(m) > 0;`
`355`	`355`	`}`
`356`	`356`
`357`		`- bool operator==(const MetaName& m) const noexcept`
	`357`	`+ bool operator==(const MetaName& m) const`
`358`	`358`	`{`
`359`	`359`	`return word == m.word;`
`360`	`360`	`}`
`361`	`361`
`362`		`- bool operator!=(const MetaName& m) const noexcept`
	`362`	`+ bool operator!=(const MetaName& m) const`
`363`	`363`	`{`
`364`	`364`	`return word != m.word;`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`void printf(const char*, ...);`
`368`	`368`	`FB_SIZE_T copyTo(char* to, FB_SIZE_T toSize) const;`
`369`		`- operator Firebird::MetaString() const noexcept;`
	`369`	`+ operator Firebird::MetaString() const;`
`370`	`370`
`371`	`371`	`protected:`
`372`		`- static void adjustLength(const char* const s, FB_SIZE_T& l) noexcept;`
	`372`	`+ static void adjustLength(const char* const s, FB_SIZE_T& l);`
`373`	`373`	`};`
`374`	`374`
`375`	`375`	`typedef Firebird::Pair<Firebird::Full<MetaName, MetaName> > MetaNamePair;`