koffi 1.1.0 → 1.1.3

package/src/parser.cc

@@ -19,34 +19,29 @@
 
 namespace RG {
 
-bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
+bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
 {
-    if (!proto.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, proto));
-        return false;
-    }
-
-    std::string hold = proto;
-
     tokens.Clear();
     offset = 0;
     valid = true;
 
-    Tokenize(hold.c_str());
+    Tokenize(str);
 
-    func->ret.type = ParseType();
-    if (func->ret.type->primitive == PrimitiveKind::Array) {
+    out_func->ret.type = ParseType();
+    if (out_func->ret.type->primitive == PrimitiveKind::Array) {
         MarkError("You are not allowed to directly return C arrays");
         return false;
     }
     if (Match("__cdecl")) {
-        func->convention = CallConvention::Cdecl;
+        out_func->convention = CallConvention::Cdecl;
     } else if (Match("__stdcall")) {
-        func->convention = CallConvention::Stdcall;
+        out_func->convention = CallConvention::Stdcall;
     } else if (Match("__fastcall")) {
-        func->convention = CallConvention::Fastcall;
+        out_func->convention = CallConvention::Fastcall;
+    } else if (Match("__thiscall")) {
+        out_func->convention = CallConvention::Thiscall;
     }
-    func->name = ParseIdentifier();
+    out_func->name = ParseIdentifier();
 
     Consume("(");
     if (offset < tokens.len && tokens[offset] != ")") {
@@ -54,7 +49,7 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
             ParameterInfo param = {};
 
             if (Match("...")) {
-                func->variadic = true;
+                out_func->variadic = true;
                 break;
             }
 
@@ -83,18 +78,18 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
 
             offset += (offset < tokens.len && IsIdentifier(tokens[offset]));
 
-            if (func->parameters.len >= MaxParameters) {
+            if (out_func->parameters.len >= MaxParameters) {
                 MarkError("Functions cannot have more than %1 parameters", MaxParameters);
                 return false;
             }
-            if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
+            if ((param.directions & 2) && ++out_func->out_parameters >= MaxOutParameters) {
                 MarkError("Functions cannot have more than out %1 parameters", MaxOutParameters);
                 return false;
             }
 
-            param.offset = func->parameters.len;
+            param.offset = out_func->parameters.len;
 
-            func->parameters.Append(param);
+            out_func->parameters.Append(param);
 
             if (offset >= tokens.len || tokens[offset] != ",")
                 break;
@@ -125,6 +120,17 @@ void PrototypeParser::Tokenize(const char *str)
             Span<const char> tok = MakeSpan(str + i, j - i);
             tokens.Append(tok);
 
+            i = j - 1;
+        } else if (IsAsciiDigit(c)) {
+            Size j = i;
+            while (str[++j] && IsAsciiDigit(str[j]));
+            if (str[j] == '.') {
+                while (str[++j] && IsAsciiDigit(str[j]));
+            }
+
+            Span<const char> tok = MakeSpan(str + i, j - i);
+            tokens.Append(tok);
+
             i = j - 1;
         } else if (c == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
             tokens.Append("...");
@@ -165,11 +171,21 @@ const TypeInfo *PrototypeParser::ParseType()
     }
     buf.ptr[--buf.len] = 0;
 
-    if (TestStr(buf, "char") && indirect) {
-        buf.RemoveFrom(0);
-        Fmt(&buf, "string");
+    if (indirect) {
+        const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
+        PrimitiveKind primitive = type ? type->primitive : PrimitiveKind::Void;
+
+        if (primitive == PrimitiveKind::Int8 || primitive == PrimitiveKind::UInt8) {
+            buf.RemoveFrom(0);
+            Fmt(&buf, "string");
+
+            indirect--;
+        } else if (primitive == PrimitiveKind::Int16 || primitive == PrimitiveKind::UInt16) {
+            buf.RemoveFrom(0);
+            Fmt(&buf, "string16");
 
-        indirect--;
+            indirect--;
+        }
     }
 
     while (buf.len) {
@@ -250,4 +266,10 @@ bool PrototypeParser::IsIdentifier(Span<const char> tok) const
     return IsAsciiAlpha(tok[0]) || tok[0] == '_';
 }
 
+bool ParsePrototype(Napi::Env env, const char *str, FunctionInfo *out_func)
+{
+    PrototypeParser parser(env);
+    return parser.Parse(str, out_func);
+}
+
 }

package/src/parser.hh

@@ -36,7 +36,7 @@ class PrototypeParser {
 public:
     PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
 
-    bool Parse(Napi::String proto, FunctionInfo *func);
+    bool Parse(const char *str, FunctionInfo *out_func);
 
 private:
     void Tokenize(const char *str);
@@ -60,4 +60,6 @@ private:
     }
 };
 
+bool ParsePrototype(Napi::Env env, const char *str, FunctionInfo *out_func);
+
 }

package/src/util.hh

@@ -78,7 +78,7 @@ T CopyNumber(const Napi::Value &value)
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
     if (RG_LIKELY(value.IsNumber())) {
-        return (T)value.As<Napi::Number>();
+        return (T)value.As<Napi::Number>().DoubleValue();
     } else if (value.IsBigInt()) {
         Napi::BigInt bigint = value.As<Napi::BigInt>();
 

package/test/CMakeLists.txt

@@ -42,6 +42,9 @@ else()
                                           -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)

package/test/misc.c

@@ -104,6 +104,13 @@ typedef struct PackedBFG {
 } PackedBFG;
 #pragma pack(pop)
 
+typedef struct FixedString {
+    char buf[64];
+} FixedString;
+typedef struct FixedWide {
+    int16_t buf[64];
+} FixedWide;
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;
@@ -359,3 +366,13 @@ EXPORT const char16_t *Concat16(const char16_t *str1, const char16_t *str2)
 
     return buf;
 }
+
+EXPORT FixedString ReturnFixedStr(FixedString str)
+{
+    return str;
+}
+
+EXPORT FixedWide ReturnFixedWide(FixedWide str)
+{
+    return str;
+}

package/vendor/libcc/libcc.cc

@@ -3745,7 +3745,7 @@ static std::atomic_bool flag_interrupt = false;
 static std::atomic_bool explicit_interrupt = false;
 static int interrupt_pfd[2] = {-1, -1};
 
-static void SetSignalHandler(int signal, struct sigaction *prev, void (*func)(int))
+void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
 {
     struct sigaction action = {};
 
@@ -3786,10 +3786,10 @@ RG_INIT(SetupDefaultHandlers)
     int ret = setpgid(0, 0);
     RG_ASSERT(!ret);
 
-    SetSignalHandler(SIGINT, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGTERM, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGHUP, nullptr, DefaultSignalHandler);
-    SetSignalHandler(SIGPIPE, nullptr, [](int) {});
+    SetSignalHandler(SIGINT, DefaultSignalHandler);
+    SetSignalHandler(SIGTERM, DefaultSignalHandler);
+    SetSignalHandler(SIGHUP, DefaultSignalHandler);
+    SetSignalHandler(SIGPIPE, [](int) {});
 }
 
 RG_EXIT(TerminateChildren)
@@ -3797,7 +3797,7 @@ RG_EXIT(TerminateChildren)
     pid_t pid = getpid();
     RG_ASSERT(pid > 1);
 
-    SetSignalHandler(SIGTERM, nullptr, [](int) {});
+    SetSignalHandler(SIGTERM, [](int) {});
     kill(-pid, SIGTERM);
 }
 
@@ -4168,7 +4168,7 @@ WaitForResult WaitForInterrupt(int64_t timeout)
     static std::atomic_bool message = false;
 
     flag_interrupt = true;
-    SetSignalHandler(SIGUSR1, nullptr, [](int) { message = true; });
+    SetSignalHandler(SIGUSR1, [](int) { message = true; });
 
     if (timeout >= 0) {
         struct timespec ts;

package/vendor/libcc/libcc.hh

@@ -35,7 +35,7 @@
 #include <utility>
 #if defined(_WIN32)
     #include <intrin.h>
-#elif !defined(__APPLE__) && (!defined(__linux__) || defined(__GLIBC__))
+#elif !defined(__APPLE__) && (!defined(__linux__) || defined(__GLIBC__)) && __has_include(<ucontext.h>)
     #define RG_FIBER_USE_UCONTEXT
     #include <ucontext.h>
 #else
@@ -54,6 +54,7 @@
     #pragma intrinsic(__rdtsc)
 #endif
 
+struct sigaction;
 struct BrotliEncoderStateStruct;
 
 namespace RG {
@@ -3929,6 +3930,8 @@ enum class PipeMode {
 bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, void *out_handles[2]); // HANDLE
 void CloseHandleSafe(void **handle_ptr); // HANDLE
 #else
+void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev = nullptr);
+
 bool CreatePipe(int pfd[2]);
 void CloseDescriptorSafe(int *fd_ptr);
 #endif