From 92b0c4778fc44e4a07ab5d13d523ba6f4cec45bc Mon Sep 17 00:00:00 2001
From: Adam Heinermann <aheinerm@gmail.com>
Date: Tue, 23 Sep 2025 15:19:21 -0700
Subject: [PATCH] chore(build): resolve MSVC warnings

---
 storm/CMakeLists.txt                    |  2 ++
 storm/hash/TSExportTableSimpleReuse.hpp |  4 ++--
 storm/hash/TSExportTableSyncReuse.hpp   |  2 +-
 test/Handle.cpp                         |  5 +++++
 test/Hash.cpp                           | 14 ++++++++------
 test/Unicode.cpp                        |  2 +-
 6 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/storm/CMakeLists.txt b/storm/CMakeLists.txt
index 2a44fae..55cea8b 100644
--- a/storm/CMakeLists.txt
+++ b/storm/CMakeLists.txt
@@ -43,6 +43,8 @@ add_library(storm STATIC
     ${STORM_SOURCES}
 )
 
+target_compile_definitions(storm PRIVATE _CRT_SECURE_NO_WARNINGS)
+
 target_include_directories(storm
     PUBLIC
         ${PROJECT_SOURCE_DIR}
diff --git a/storm/hash/TSExportTableSimpleReuse.hpp b/storm/hash/TSExportTableSimpleReuse.hpp
index f2a1854..e44203a 100644
--- a/storm/hash/TSExportTableSimpleReuse.hpp
+++ b/storm/hash/TSExportTableSimpleReuse.hpp
@@ -43,12 +43,12 @@ THandle TSExportTableSimpleReuse<T, THandle>::GenerateUniqueHandle() {
             this->m_wrapped = 1;
         }
 
-        if (!this->m_wrapped || !this->Ptr(reinterpret_cast<THandle>(this->m_sequence))) {
+        if (!this->m_wrapped || !this->Ptr(reinterpret_cast<THandle>(static_cast<uintptr_t>(this->m_sequence)))) {
             break;
         }
     }
 
-    return reinterpret_cast<THandle>(this->m_sequence);
+    return reinterpret_cast<THandle>(static_cast<uintptr_t>(this->m_sequence));
 }
 
 template <class T, class THandle>
diff --git a/storm/hash/TSExportTableSyncReuse.hpp b/storm/hash/TSExportTableSyncReuse.hpp
index 21fdb64..5194ba4 100644
--- a/storm/hash/TSExportTableSyncReuse.hpp
+++ b/storm/hash/TSExportTableSyncReuse.hpp
@@ -69,7 +69,7 @@ T* TSExportTableSyncReuse<T, THandle, TLockedHandle, TSync>::NewLock(THandle* ha
 template <class T, class THandle, class TLockedHandle, class TSync>
 void TSExportTableSyncReuse<T, THandle, TLockedHandle, TSync>::SyncEnterLock(TLockedHandle* lockedHandlePtr, int32_t forWriting) {
     this->m_sync.Enter(forWriting);
-    *lockedHandlePtr = reinterpret_cast<TLockedHandle>(forWriting ? 1 : -1);
+    *lockedHandlePtr = reinterpret_cast<TLockedHandle>(static_cast<intptr_t>(forWriting ? 1 : -1));
 }
 
 template <class T, class THandle, class TLockedHandle, class TSync>
diff --git a/test/Handle.cpp b/test/Handle.cpp
index 9778237..7e68fc1 100644
--- a/test/Handle.cpp
+++ b/test/Handle.cpp
@@ -1,11 +1,14 @@
 #include "storm/Handle.hpp"
 #include "test/Test.hpp"
 
+#define UNUSED(x) ((void)x)
+
 TEST_CASE("DECLARE_STORM_HANDLE", "[handle]") {
     SECTION("declares handle") {
         DECLARE_STORM_HANDLE(HTEST);
         HTEST test;
 
+        UNUSED(test);
         SUCCEED();
     }
 }
@@ -18,6 +21,8 @@ TEST_CASE("DECLARE_STORM_CHILD_HANDLE", "[handle]") {
         HPARENT parent;
         HCHILD child;
 
+        UNUSED(parent);
+        UNUSED(child);
         SUCCEED();
     }
 }
diff --git a/test/Hash.cpp b/test/Hash.cpp
index 02fec78..b9dd14f 100644
--- a/test/Hash.cpp
+++ b/test/Hash.cpp
@@ -1,6 +1,7 @@
 #include "storm/Hash.hpp"
 #include "storm/Thread.hpp"
 #include "test/Test.hpp"
+#include <cstdint>
 
 struct TestHashObject : TSHashObject<TestHashObject, HASHKEY_STRI> {
     uint32_t index = 255;
@@ -11,15 +12,16 @@ struct TestExportObject : TSHashObject<TestHashObject, HASHKEY_NONE> {
 };
 
 typedef void* TestExportObjectHandle;
-
 typedef void* TestExportLockedHandle;
 
+#define MAKEINTPTR(x) reinterpret_cast<void*>(static_cast<uintptr_t>(x));
+
 TEST_CASE("HASHKEY_PTR", "[hash]") {
     SECTION("constructs correctly") {
         HASHKEY_PTR key1;
         REQUIRE(key1.GetPtr() == nullptr);
 
-        void* ptr = reinterpret_cast<void*>(0xDEAFBEEF);
+        void* ptr = MAKEINTPTR(0xDEAFBEEF);
         HASHKEY_PTR key2 = { ptr };
         REQUIRE(key2.GetPtr() == ptr);
     }
@@ -27,9 +29,9 @@ TEST_CASE("HASHKEY_PTR", "[hash]") {
 
 TEST_CASE("HASHKEY_PTR::operator=") {
     SECTION("assigns from another key") {
-        void* ptr1 = reinterpret_cast<void*>(0xDEAFBEEF);
+        void* ptr1 = MAKEINTPTR(0xDEAFBEEF);
         HASHKEY_PTR key1 = { ptr1 };
-        void* ptr2 = reinterpret_cast<void*>(0xFEEDFACE);
+        void* ptr2 = MAKEINTPTR(0xFEEDFACE);
         HASHKEY_PTR key2 = { ptr2 };
         REQUIRE (!(key1 == key2));
 
@@ -40,12 +42,12 @@ TEST_CASE("HASHKEY_PTR::operator=") {
 
 TEST_CASE("HASHKEY_PTR::operator==") {
     SECTION("compares to another key") {
-        void* ptr1 = reinterpret_cast<void*>(0xDEAFBEEF);
+        void* ptr1 = MAKEINTPTR(0xDEAFBEEF);
         HASHKEY_PTR key1 = { ptr1 };
         HASHKEY_PTR key2 = { ptr1 };
         REQUIRE(key1 == key2);
 
-        void* ptr2 = reinterpret_cast<void*>(0xFEEDFACE);
+        void* ptr2 = MAKEINTPTR(0xFEEDFACE);
         HASHKEY_PTR key3 = { ptr2 };
         REQUIRE(!(key1 == key3));
     }
diff --git a/test/Unicode.cpp b/test/Unicode.cpp
index 3e61ec3..f7e29db 100644
--- a/test/Unicode.cpp
+++ b/test/Unicode.cpp
@@ -27,7 +27,7 @@ TEST_CASE("SUniSGetUTF8", "[unicode]") {
         int32_t chars = 0;
         auto code = SUniSGetUTF8(reinterpret_cast<const uint8_t*>(string), &chars);
 
-        REQUIRE(code == -1u);
+        REQUIRE(code == ~0u);
         REQUIRE(chars == 0);
     }
 }