koffi 2.6.3 → 2.6.5

package/src/core/libcc/libcc.hh

@@ -3853,9 +3853,6 @@ Size ConvertWin32WideToUtf8(const wchar_t *str_w, Span<char> out_str);
 char *GetWin32ErrorString(uint32_t error_code = UINT32_MAX);
 #endif
 
-void SetEnvironmentVar(const char *name, const char *value);
-void DeleteEnvironmentVar(const char *name);
-
 static inline bool IsPathSeparator(char c)
 {
 #ifdef _WIN32
@@ -4055,17 +4052,29 @@ bool CreatePipe(int pfd[2]);
 void CloseDescriptorSafe(int *fd_ptr);
 #endif
 
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+struct ExecuteInfo {
+    struct KeyValue {
+        const char *key;
+        const char *value;
+    };
+
+    const char *work_dir = nullptr;
+
+    bool reset_env = false;
+    Span<const KeyValue> env_variables = {};
+};
+
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         FunctionRef<Span<const uint8_t>()> in_func,
                         FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code);
-bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         Span<const uint8_t> in_buf, Size max_len,
                         HeapArray<uint8_t> *out_buf, int *out_code);
 
 // Simple variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir, int *out_code)
-    { return ExecuteCommandLine(cmd_line, work_dir, {}, {}, out_code); }
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,int *out_code)
+    { return ExecuteCommandLine(cmd_line, info, {}, {}, out_code); }
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const uint8_t> in_buf,
                                       FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
@@ -4075,22 +4084,22 @@ static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir
         return buf;
     };
 
-    return ExecuteCommandLine(cmd_line, work_dir, read_once, out_func, out_code);
+    return ExecuteCommandLine(cmd_line, info, read_once, out_func, out_code);
 }
 
 // Char variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const char> in_buf,
                                       FunctionRef<void(Span<char> buf)> out_func, int *out_code)
 {
     const auto write = [&](Span<uint8_t> buf) { out_func(buf.As<char>()); };
-    return ExecuteCommandLine(cmd_line, work_dir, in_buf.As<const uint8_t>(), write, out_code);
+    return ExecuteCommandLine(cmd_line, info, in_buf.As<const uint8_t>(), write, out_code);
 }
-static inline bool ExecuteCommandLine(const char *cmd_line, const char *work_dir,
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const char> in_buf, Size max_len,
                                       HeapArray<char> *out_buf, int *out_code)
 {
-    return ExecuteCommandLine(cmd_line, work_dir, in_buf.As<const uint8_t>(), max_len,
+    return ExecuteCommandLine(cmd_line, info, in_buf.As<const uint8_t>(), max_len,
                               (HeapArray<uint8_t> *)out_buf, out_code);
 }
 
@@ -4158,6 +4167,11 @@ const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix
 // Random
 // ------------------------------------------------------------------------
 
+void ZeroMemorySafe(void *ptr, Size len);
+void FillRandomSafe(void *buf, Size len);
+static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
+int GetRandomIntSafe(int min, int max);
+
 class FastRandom {
     uint64_t state[4];
 
@@ -4190,10 +4204,7 @@ public:
     int operator()() { return rng.GetInt(Min, Max); }
 };
 
-void ZeroMemorySafe(void *ptr, Size len);
-void FillRandomSafe(void *buf, Size len);
-static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
-int GetRandomIntSafe(int min, int max);
+int GetRandomIntFast(int min, int max);
 
 // ------------------------------------------------------------------------
 // Sockets
@@ -4269,7 +4280,8 @@ class Fiber {
 #elif defined(RG_FIBER_USE_UCONTEXT)
     ucontext_t ucp = {};
 #else
-    std::thread thread;
+    pthread_t thread;
+    bool joinable = false;
 
     std::mutex mutex;
     std::condition_variable cv;
@@ -4297,7 +4309,7 @@ private:
 #elif defined(RG_FIBER_USE_UCONTEXT)
     static void FiberCallback(unsigned int high, unsigned int low);
 #else
-    static void ThreadCallback(void *udata);
+    static void *ThreadCallback(void *udata);
     void Toggle(int to, std::unique_lock<std::mutex> *lock);
 #endif
 };

package/src/koffi/CMakeLists.txt

@@ -31,17 +31,17 @@ find_package(CNoke)
 set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
-
-    add_compile_options(/Zc:__cplusplus /W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702 /wd4201 /wd4324)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zc:__cplusplus /W4 /wd4200 /wd4201 /wd4127 /wd4458 /wd4706 /wd4702 /wd4324")
 
     # ASM_MASM does not (yet) work on Windows ARM64
     if(NOT CMAKE_GENERATOR_PLATFORM MATCHES "ARM64")
         enable_language(ASM_MASM)
     endif()
 else()
-    add_compile_options(-Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wswitch -Werror=switch)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-missing-field-initializers -Wno-unused-parameter -Wswitch -Werror=switch")
+
     if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        add_compile_options(-Wno-unknown-warning-option)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unknown-warning-option")
     endif()
 endif()
 
@@ -132,16 +132,16 @@ if(NOT MSVC OR CMAKE_C_COMPILER_ID MATCHES "[Cc]lang")
     # Restore C/C++ compiler sanity
 
     if(NOT MSVC)
-        target_compile_options(koffi PRIVATE -fno-exceptions -fno-strict-aliasing -fwrapv
-                                             -fno-delete-null-pointer-checks)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions -fno-strict-aliasing -fwrapv
+                                                                       -fno-delete-null-pointer-checks>)
     else()
-        target_compile_options(koffi PRIVATE -fno-strict-aliasing /clang:-fwrapv
-                                             -fno-delete-null-pointer-checks)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-strict-aliasing /clang:-fwrapv
+                                                                       -fno-delete-null-pointer-checks>)
     endif()
 
     check_cxx_compiler_flag(-fno-finite-loops use_no_finite_loops)
     if(use_no_finite_loops)
-        target_compile_options(koffi PRIVATE -fno-finite-loops)
+        target_compile_options(koffi PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-fno-finite-loops>)
     endif()
 endif()
 enable_unity_build(koffi)

package/src/koffi/cmake/raylib.cmake

@@ -0,0 +1,98 @@
+# Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the “Software”), to deal in 
+# the Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+add_library(raylib SHARED
+    ../../../vendor/raylib/src/rcore.c
+    ../../../vendor/raylib/src/rshapes.c
+    ../../../vendor/raylib/src/rtextures.c
+    ../../../vendor/raylib/src/rtext.c
+    ../../../vendor/raylib/src/rmodels.c
+    ../../../vendor/raylib/src/utils.c
+    ../../../vendor/raylib/src/rglfw.c
+    ../../../vendor/raylib/src/raudio.c
+)
+set_target_properties(raylib PROPERTIES PREFIX "")
+target_include_directories(raylib PRIVATE ../../../vendor/raylib/src/external/glfw/include)
+target_compile_definitions(raylib PRIVATE PLATFORM_DESKTOP GRAPHICS_API_OPENGL_21 BUILD_LIBTYPE_SHARED NDEBUG)
+
+if(MSVC)
+    target_compile_options(raylib PRIVATE /wd4244 /wd4305)
+else()
+    target_compile_options(raylib PRIVATE -Wno-sign-compare -Wno-old-style-declaration
+                                          -Wno-unused-function -Wno-missing-field-initializers
+                                          -Wno-unused-value -Wno-implicit-fallthrough -Wno-stringop-overflow
+                                          -Wno-unused-result)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(raylib PRIVATE -Wno-unknown-warning-option)
+    endif()
+endif()
+
+if(WIN32)
+    target_compile_definitions(raylib PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
+    target_link_libraries(raylib PRIVATE winmm)
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "BSD")
+    target_include_directories(raylib PRIVATE /usr/local/include)
+endif()
+
+if(APPLE)
+    target_compile_options(raylib PRIVATE -Wno-unknown-warning-option -Wno-macro-redefined)
+    target_compile_definitions(raylib PRIVATE GL_SILENCE_DEPRECATION)
+    set_source_files_properties(../../../vendor/raylib/src/rglfw.c PROPERTIES COMPILE_FLAGS "-x objective-c")
+    target_link_libraries(raylib PRIVATE "-framework Cocoa" "-framework IOKit" "-framework CoreFoundation" "-framework OpenGL")
+endif()
+
+if(UNIX AND NOT APPLE)
+    set(missing_xlib "")
+
+    find_path(XLIB_INCLUDE_DIRS X11/Xlib.h)
+    if(NOT XLIB_INCLUDE_DIRS)
+        list(APPEND missing_xlib Xlib)
+    endif()
+    find_path(XCURSOR_INCLUDE_DIRS X11/Xcursor/Xcursor.h)
+    if(NOT XCURSOR_INCLUDE_DIRS)
+        list(APPEND missing_xlib Xcursor)
+    endif()
+    find_path(XRANDR_INCLUDE_DIRS X11/extensions/Xrandr.h)
+    if(NOT XRANDR_INCLUDE_DIRS)
+        list(APPEND missing_xlib Xrandr)
+    endif()
+    find_path(XKB_INCLUDE_DIRS X11/XKBlib.h)
+    if(NOT XKB_INCLUDE_DIRS)
+        list(APPEND missing_xlib Xkbcommon)
+    endif()
+    find_path(XINERAMA_INCLUDE_DIRS X11/extensions/Xinerama.h)
+    if(NOT XINERAMA_INCLUDE_DIRS)
+        list(APPEND missing_xlib Xinerama)
+    endif()
+    find_path(XINPUT_INCLUDE_DIRS X11/extensions/XInput2.h)
+    if(NOT XINPUT_INCLUDE_DIRS)
+        list(APPEND missing_xlib XInput2)
+    endif()
+
+    if(missing_xlib)
+        list(JOIN missing_xlib ", " missing_xlib_str)
+        message(FATAL_ERROR "Missing X11 development files: ${missing_xlib_str}")
+    endif()
+
+    target_include_directories(raylib PRIVATE ${XLIB_INCLUDE_DIRS})
+endif()

package/src/koffi/cmake/sqlite.cmake

@@ -0,0 +1,27 @@
+# Copyright 2023 Niels Martignène <niels.martignene@protonmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the “Software”), to deal in 
+# the Software without restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+# Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+
+add_library(sqlite3 SHARED ../../../vendor/sqlite3/sqlite3.c)
+set_target_properties(sqlite3 PROPERTIES PREFIX "")
+
+if(WIN32)
+    target_compile_definitions(sqlite3 PRIVATE SQLITE_API=__declspec\(dllexport\))
+endif()

package/src/koffi/src/ffi.cc

@@ -225,18 +225,38 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         return env.Null();
     }
 
+    RG_DEFER_NC(err_guard, len = instance->types.len) {
+        for (Size i = len + 1; i < instance->types.len; i++) {
+            const TypeInfo &type = instance->types[i];
+            instance->types_map.Remove(type.name);
+        }
+
+        instance->types.RemoveFrom(len);
+    };
+
     TypeInfo *type = instance->types.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
-    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
+    if (named) {
+        type->name = DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr;
+
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
+    } else {
+        type->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
+    }
 
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
+    type->flags = (int)TypeFlag::IsIncomplete;
 
     HashSet<const char *> members;
     int64_t size = 0;
@@ -308,16 +328,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     }
     type->size = (int32_t)size;
 
-    // If the insert succeeds, we cannot fail anymore
-    if (named) {
-        bool inserted;
-        instance->types_map.TrySet(type->name, type, &inserted);
-
-        if (!inserted) {
-            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-            return env.Null();
-        }
-    }
+    type->flags &= ~(int)TypeFlag::IsIncomplete;
     err_guard.Disable();
 
     return WrapType(env, instance, type);
@@ -354,18 +365,38 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+    RG_DEFER_NC(err_guard, len = instance->types.len) {
+        for (Size i = len + 1; i < instance->types.len; i++) {
+            const TypeInfo &type = instance->types[i];
+            instance->types_map.Remove(type.name);
+        }
+
+        instance->types.RemoveFrom(len);
+    };
+
     TypeInfo *type = instance->types.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
-    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
-                       : Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
+    if (named) {
+        type->name = DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr;
+
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
+    } else {
+        type->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.len).ptr;
+    }
 
     type->primitive = PrimitiveKind::Union;
     type->align = 1;
+    type->flags = (int)TypeFlag::IsIncomplete;
 
     HashSet<const char *> members;
     int32_t size = 0;
@@ -428,16 +459,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     }
     type->size = (int32_t)size;
 
-    // If the insert succeeds, we cannot fail anymore
-    if (named) {
-        bool inserted;
-        instance->types_map.TrySet(type->name, type, &inserted);
-
-        if (!inserted) {
-            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-            return env.Null();
-        }
-    }
+    type->flags &= ~(int)TypeFlag::IsIncomplete;
     err_guard.Disable();
 
     // Union constructor
@@ -2224,7 +2246,7 @@ static Napi::Value ResetKoffi(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
-static InstanceData *CreateInstance(Napi::Env env)
+static InstanceData *CreateInstance()
 {
     InstanceData *instance = new InstanceData();
     RG_DEFER_N(err_guard) { delete instance; };
@@ -2247,7 +2269,7 @@ static InstanceData *CreateInstance(Napi::Env env)
 
 static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
 {
-    InstanceData *instance = CreateInstance(env);
+    InstanceData *instance = CreateInstance();
     RG_CRITICAL(instance, "Failed to initialize Koffi");
 
     env.SetInstanceData(instance);

package/src/koffi/src/ffi.hh

@@ -104,8 +104,9 @@ class CallData;
 typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
 
 enum class TypeFlag {
-    HasTypedArray = 1 << 0,
-    IsCharLike = 1 << 1
+    IsIncomplete = 1 << 0,
+    HasTypedArray = 1 << 1,
+    IsCharLike = 1 << 2
 };
 
 enum class ArrayHint {

package/src/koffi/src/util.cc

@@ -120,7 +120,9 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
         const TypeInfo *type = ResolveType(env, str.c_str(), out_directions);
 
         if (!type) {
-            ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+            if (!env.IsExceptionPending()) {
+                ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
+            }
             return nullptr;
         }
 
@@ -299,6 +301,11 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         RG_ASSERT(type);
     }
 
+    if (type->flags & (int)TypeFlag::IsIncomplete) [[unlikely]] {
+        ThrowError<Napi::TypeError>(env, "Cannot directly use incomplete type");
+        return nullptr;
+    }
+
     return type;
 }
 

package/src/koffi/src/win32.cc

@@ -79,7 +79,7 @@ static bool ReadAt(HANDLE h, int32_t offset, void *buf, int len)
         return false;
     if (!ReadFile(h, buf, (DWORD)len, &read, &ov))
         return false;
-    if (read != len)
+    if (read != (DWORD)len)
         return false;
 
     return true;