koffi 1.1.1 → 1.1.2

package/CMakeLists.txt

@@ -23,6 +23,9 @@ if(MSVC)
 else()
     add_compile_options(-Wall -Wextra -Wno-missing-field-initializers
                         -Wno-unused-parameter -Wno-class-memaccess)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        add_compile_options(-Wno-unknown-warning-option)
+    endif()
 endif()
 
 # ---- Koffi ----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -24,7 +24,7 @@
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^1.0.7"
+    "cnoke": "^1.0.9"
   },
   "devDependencies": {
     "chalk": "^4.1.2",

package/src/call.cc

@@ -252,8 +252,8 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                     return false;
                 }
 
-                Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, dest, realign))
+                Napi::Object obj2 = value.As<Napi::Object>();
+                if (!PushObject(obj2, member.type, dest, realign))
                     return false;
             } break;
             case PrimitiveKind::Array: {
@@ -292,15 +292,15 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
-bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t *dest, int16_t realign)
+bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    RG_ASSERT(value.IsArray() || value.IsTypedArray() || value.IsString());
+    RG_ASSERT(obj.IsArray() || obj.IsTypedArray() || obj.IsString());
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
 
-    if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
+    if (obj.IsArray()) {
+        Napi::Array array = obj.As<Napi::Array>();
 
         if (RG_UNLIKELY(array.Length() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
@@ -407,15 +407,15 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::Record: {
                 PUSH_ARRAY(IsObject(value), "object", {
-                    Napi::Object obj = value.As<Napi::Object>();
-                    if (!PushObject(obj, type->ref, dest, realign))
+                    Napi::Object obj2 = value.As<Napi::Object>();
+                    if (!PushObject(obj2, type->ref, dest, realign))
                         return false;
                 });
             } break;
             case PrimitiveKind::Array: {
                 PUSH_ARRAY(value.IsArray() || value.IsTypedArray() || value.IsString(), "array", {
-                    Napi::Object array = value.As<Napi::Array>();
-                    if (!PushArray(array, type->ref, dest, realign))
+                    Napi::Object array2 = value.As<Napi::Array>();
+                    if (!PushArray(array2, type->ref, dest, realign))
                         return false;
                 });
             } break;
@@ -434,8 +434,8 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
         }
 
 #undef PUSH_ARRAY
-    } else if (value.IsTypedArray()) {
-        Napi::TypedArray array = value.As<Napi::TypedArray>();
+    } else if (obj.IsTypedArray()) {
+        Napi::TypedArray array = obj.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
         if (RG_UNLIKELY(array.ElementLength() != len)) {
@@ -469,23 +469,23 @@ bool CallData::PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t
 
             dest += type->ref->size;
         }
-    } else if (value.IsString()) {
-        size_t len = 0;
+    } else if (obj.IsString()) {
+        size_t encoded = 0;
 
         if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
-            napi_status status = napi_get_value_string_utf8(env, value, (char *)dest, type->size, &len);
+            napi_status status = napi_get_value_string_utf8(env, obj, (char *)dest, type->size, &encoded);
             RG_ASSERT(status == napi_ok);
         } else if (type->ref->primitive == PrimitiveKind::Int16 || type->ref->primitive == PrimitiveKind::UInt16) {
-            napi_status status = napi_get_value_string_utf16(env, value, (char16_t *)dest, type->size / 2, &len);
+            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)dest, type->size / 2, &encoded);
             RG_ASSERT(status == napi_ok);
 
-            len *= 2;
+            encoded *= 2;
         } else {
             ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
             return false;
         }
 
-        memset_safe(dest + len, 0, type->size - len);
+        memset_safe(dest + encoded, 0, type->size - encoded);
     } else {
         RG_UNREACHABLE();
     }

package/src/call.hh

@@ -78,7 +78,7 @@ private:
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
     bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
-    bool PushArray(const Napi::Value &value, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
 
     void PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
     Napi::Object PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);

package/src/ffi.cc

@@ -653,9 +653,13 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
             return env.Null();
     } else if (info.Length() >= 1) {
-        PrototypeParser parser(env);
+        if (!info[0].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, info[0]));
+            return env.Null();
+        }
 
-        if (!parser.Parse(info[0u].As<Napi::String>(), func))
+        std::string proto = info[0u].As<Napi::String>();
+        if (!ParsePrototype(env, proto.c_str(), func))
             return env.Null();
     } else {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
@@ -957,7 +961,6 @@ static void SetExports(Napi::Env env, Func func)
     func("out", Napi::Function::New(env, MarkOut));
     func("inout", Napi::Function::New(env, MarkInOut));
 
-    func("internal", Napi::Boolean::New(env, true));
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));
 #elif defined(__APPLE__)
@@ -1009,6 +1012,7 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env_napi, [&](const char *name, Napi::Value value) { SetValue(env, target, name, value); });
+    SetValue(env, target, "internal", Napi::Boolean::New(env_cxx, true));
 }
 
 #else
@@ -1024,6 +1028,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env, [&](const char *name, Napi::Value value) { exports.Set(name, value); });
+    exports.Set("internal", Napi::Boolean::New(env, false));
 
     return exports;
 }

package/src/parser.cc

@@ -19,34 +19,27 @@
 
 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;
     }
-    func->name = ParseIdentifier();
+    out_func->name = ParseIdentifier();
 
     Consume("(");
     if (offset < tokens.len && tokens[offset] != ")") {
@@ -54,7 +47,7 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
             ParameterInfo param = {};
 
             if (Match("...")) {
-                func->variadic = true;
+                out_func->variadic = true;
                 break;
             }
 
@@ -83,18 +76,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 +118,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("...");
@@ -250,4 +254,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);
+
 }