clean up number -> hex -> number code

2 files changed, 75 insertions, 50 deletions

diff --git a/zencore/include/zencore/string.h b/zencore/include/zencore/string.h
index 013f2f568..da5a50064 100644
--- a/zencore/include/zencore/string.h
+++ b/zencore/include/zencore/string.h
@@ -488,6 +488,29 @@ std::string WideToUtf8(const wchar_t* wstr);
 void		WideToUtf8(const std::wstring_view& wstr, StringBuilderBase& out);
 std::string WideToUtf8(const std::wstring_view Wstr);
 
+inline uint8_t
+Char2Nibble(char c)
+{
+	uint8_t c8 = uint8_t(c - '0');
+
+	if (c8 < 10)
+		return c8;
+
+	c8 -= 'A' - '0' - 10;
+
+	if (c8 < 16)
+		return c8;
+
+	c8 -= 'a' - 'A';
+
+	if (c8 < 16)
+		return c8;
+
+	return uint8_t(0xff);
+};
+
+static constexpr const char HexChars[] = "0123456789abcdef";
+
 /// <summary>
 /// Parse hex string into a byte buffer
 /// </summary>
@@ -501,38 +524,56 @@ ParseHexBytes(const char* InputString, size_t CharacterCount, uint8_t* OutPtr)
 {
 	ZEN_ASSERT((CharacterCount & 1) == 0);
 
-	auto char2nibble = [](char c) {
-		uint8_t c8 = uint8_t(c - '0');
+	uint8_t allBits = 0;
 
-		if (c8 < 10)
-			return c8;
+	while (CharacterCount)
+	{
+		uint8_t n0 = Char2Nibble(InputString[0]);
+		uint8_t n1 = Char2Nibble(InputString[1]);
 
-		c8 -= 'A' - '0' - 10;
+		allBits |= n0 | n1;
 
-		if (c8 < 16)
-			return c8;
+		*OutPtr = (n0 << 4) | n1;
 
-		c8 -= 'a' - 'A';
+		OutPtr += 1;
+		InputString += 2;
+		CharacterCount -= 2;
+	}
 
-		if (c8 < 16)
-			return c8;
+	return (allBits & 0x80) == 0;
+}
 
-		return uint8_t(0xff);
-	};
+inline void
+ToHexBytes(const uint8_t* InputData, size_t ByteCount, char* OutString)
+{
+	while (ByteCount--)
+	{
+		uint8_t byte = *InputData++;
+
+		*OutString++ = HexChars[byte >> 4];
+		*OutString++ = HexChars[byte & 15];
+	}
+}
+
+inline bool
+ParseHexNumber(const char* InputString, size_t CharacterCount, uint8_t* OutPtr)
+{
+	ZEN_ASSERT((CharacterCount & 1) == 0);
 
 	uint8_t allBits = 0;
 
+	InputString += CharacterCount;
 	while (CharacterCount)
 	{
-		uint8_t n0 = char2nibble(InputString[0]);
-		uint8_t n1 = char2nibble(InputString[1]);
+		InputString -= 2;
+		uint8_t n0 = Char2Nibble(InputString[0]);
+		uint8_t n1 = Char2Nibble(InputString[1]);
 
 		allBits |= n0 | n1;
 
 		*OutPtr = (n0 << 4) | n1;
 
 		OutPtr += 1;
-		InputString += 2;
 		CharacterCount -= 2;
 	}
 
@@ -540,21 +581,32 @@ ParseHexBytes(const char* InputString, size_t CharacterCount, uint8_t* OutPtr)
 }
 
 inline void
-ToHexBytes(const uint8_t* InputData, size_t ByteCount, char* OutString)
+ToHexNumber(const uint8_t* InputData, size_t ByteCount, char* OutString)
 {
-	const char hexchars[] = "0123456789abcdef";
-
+	InputData += ByteCount;
 	while (ByteCount--)
 	{
-		uint8_t byte = *InputData++;
+		uint8_t byte = *(--InputData);
 
-		*OutString++ = hexchars[byte >> 4];
-		*OutString++ = hexchars[byte & 15];
+		*OutString++ = HexChars[byte >> 4];
+		*OutString++ = HexChars[byte & 15];
 	}
 }
 
-ZENCORE_API void ToHex(uint32_t Value, char OutBlockHexString[9]);
-ZENCORE_API bool ParseHex(const std::string HexString, uint32_t& OutValue);
+template<typename T>
+void
+ToHexNumber(T Value, char* OutString)
+{
+	ToHexNumber((const uint8_t*)&Value, sizeof(T), OutString);
+	OutString[sizeof(T) * 2] = 0;
+}
+
+template<typename T>
+bool
+ParseHexNumber(const std::string HexString, T& OutValue)
+{
+	return ParseHexNumber(HexString.c_str(), sizeof(T) * 2, (uint8_t*)&OutValue);
+}
 
 //////////////////////////////////////////////////////////////////////////
 // Format numbers for humans
diff --git a/zencore/string.cpp b/zencore/string.cpp
index 933d210e7..ad6ee78fc 100644
--- a/zencore/string.cpp
+++ b/zencore/string.cpp
@@ -335,33 +335,6 @@ NiceNumGeneral(uint64_t Num, std::span<char> Buffer, NicenumFormat Format)
 	}
 }
 
-bool
-ParseHex(const std::string HexString, uint32_t& OutValue)
-{
-	if (HexString.length() != 8)
-	{
-		return false;
-	}
-	OutValue = strtoul(HexString.data(), 0, 16);
-	return true;
-}
-
-static const char HexLUT[] = "0123456789abcdef";
-
-void
-ToHex(uint32_t Value, char OutBlockHexString[9])
-{
-	OutBlockHexString[0] = HexLUT[(Value >> 28) & 0xf];
-	OutBlockHexString[1] = HexLUT[(Value >> 24) & 0xf];
-	OutBlockHexString[2] = HexLUT[(Value >> 20) & 0xf];
-	OutBlockHexString[3] = HexLUT[(Value >> 16) & 0xf];
-	OutBlockHexString[4] = HexLUT[(Value >> 12) & 0xf];
-	OutBlockHexString[5] = HexLUT[(Value >> 8) & 0xf];
-	OutBlockHexString[6] = HexLUT[(Value >> 4) & 0xf];
-	OutBlockHexString[7] = HexLUT[(Value >> 0) & 0xf];
-	OutBlockHexString[8] = 0;
-}
-
 size_t
 NiceNumToBuffer(uint64_t Num, std::span<char> Buffer)
 {