koffi 2.6.11 → 2.7.0

package/src/core/libcc/mimetypes_gen.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+# 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.
+
+# This script uses the database of mimetypes distributed here: https://github.com/jshttp/mime-db
+# to produce the X-header file mimetypes.inc
+
+import os
+import argparse
+import json
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description = 'Update mimetypes include file')
+    parser.add_argument('-O', '--output_file', dest = 'output_file', action = 'store', help = 'Output file')
+    parser.add_argument('json', help = 'Source JSON database')
+    args = parser.parse_args()
+
+    if args.output_file is None:
+        output_file = os.path.join(os.path.dirname(__file__), 'mimetypes.inc')
+    else:
+        output_file = args.output_file
+
+    with open(args.json) as f:
+        db = json.load(f)
+
+    extensions = {}
+    for (k, v) in db.items():
+        if 'extensions' not in v:
+            continue
+
+        for ext in v['extensions']:
+            if not ext in extensions:
+                extensions[ext] = 'application/x-'
+            if extensions[ext].startswith('application/x-'):
+                extensions[ext] = k
+
+    extensions = [(k, extensions[k]) for k in sorted(extensions.keys())]
+    extensions.sort()
+
+    with open(output_file) as f:
+        lines = f.readlines()
+    with open(output_file, 'w') as f:
+        for line in lines:
+            if not line.startswith('//'):
+                break
+            f.write(line)
+
+        print('', file = f)
+        print('#ifndef MIMETYPE', file = f)
+        print('    #error Please define MIMETYPE() before including mimetypes.inc', file = f)
+        print('#endif', file = f)
+        print('', file = f)
+
+        for k, v in extensions:
+            print(f'MIMETYPE(".{k}", "{v}")', file = f)
+
+        print('', file = f)
+        print('#undef MIMETYPE', file = f)

package/src/koffi/src/ffi.cc

@@ -880,35 +880,50 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
-static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
-                                 Napi::Array parameters, FunctionInfo *func)
+static bool ParseClassicFunction(const Napi::CallbackInfo &info, FunctionInfo *out_func)
 {
+    Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
+    Napi::String name = info[0u].As<Napi::String>();
+    Napi::Value ret = info[1u];
+    Napi::Array parameters = info[2u].As<Napi::Array>();
+
+    // Detect optional call convention
+    if (name.IsString() && DetectCallConvention(name.Utf8Value().c_str(), &out_func->convention)) {
+        if (info.Length() < 4) {
+            ThrowError<Napi::TypeError>(env, "Expected 4 arguments, got %1", info.Length());
+            return false;
+        }
+
+        name = info[1u].As<Napi::String>();
+        ret = info[2u];
+        parameters = info[3u].As<Napi::Array>();
+    }
+
 #ifdef _WIN32
-    if (!name.IsString() && !name.IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
-        return false;
+    if (name.IsNumber()) {
+        out_func->ordinal_name = name.As<Napi::Number>().Int32Value();
+        name = name.ToString();
     }
-#else
+#endif
     if (!name.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
         return false;
     }
-#endif
 
-    func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
+    out_func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
 
-    func->ret.type = ResolveType(ret);
-    if (!func->ret.type)
+    out_func->ret.type = ResolveType(ret);
+    if (!out_func->ret.type)
         return false;
-    if (!CanReturnType(func->ret.type)) {
-        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", func->ret.type->name);
+    if (!CanReturnType(out_func->ret.type)) {
+        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
     }
 
     if (!parameters.IsArray()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), out_func->name);
         return false;
     }
 
@@ -918,7 +933,7 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         Napi::String str = parameters.Get(parameters_len - 1).As<Napi::String>();
 
         if (str.IsString() && str.Utf8Value() == "...") {
-            func->variadic = true;
+            out_func->variadic = true;
             parameters_len--;
         }
     }
@@ -934,21 +949,21 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return false;
         }
-        if (func->parameters.len >= MaxParameters) {
+        if (out_func->parameters.len >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return false;
         }
-        if ((param.directions & 2) && ++func->out_parameters >= MaxParameters) {
+        if ((param.directions & 2) && ++out_func->out_parameters >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
             return false;
         }
 
         param.offset = (int8_t)j;
 
-        func->parameters.Append(param);
+        out_func->parameters.Append(param);
     }
 
-    func->required_parameters = (int8_t)func->parameters.len;
+    out_func->required_parameters = (int8_t)out_func->parameters.len;
 
     return true;
 }
@@ -962,7 +977,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     RG_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
 
     if (info.Length() >= 3) {
-        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+        if (!ParseClassicFunction(info, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1519,7 +1534,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
     }
 }
 
-static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
+static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1529,10 +1544,9 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     RG_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
-    func->convention = convention;
 
     if (info.Length() >= 3) {
-        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+        if (!ParseClassicFunction(info, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1562,7 +1576,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
 #ifdef _WIN32
-    if (info[0].IsString()) {
+    if (func->ordinal_name < 0) {
         if (func->decorated_name) {
             func->native = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
         }
@@ -1570,7 +1584,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
             func->native = (void *)GetProcAddress((HMODULE)lib->module, func->name);
         }
     } else {
-        uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
+        uint16_t ordinal = (uint16_t)func->ordinal_name;
 
         func->decorated_name = nullptr;
         func->native = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)(size_t)ordinal);
@@ -1720,20 +1734,13 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
-#define ADD_CONVENTION(Name, Value) ADD_METHOD((Name), FindLibraryFunction(info, Value))
-
-    ADD_CONVENTION("func", CallConvention::Cdecl);
-    ADD_CONVENTION("cdecl", CallConvention::Cdecl);
-    ADD_CONVENTION("stdcall", CallConvention::Stdcall);
-    ADD_CONVENTION("fastcall", CallConvention::Fastcall);
-    ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
+    ADD_METHOD("func", FindLibraryFunction(info));
     ADD_METHOD("symbol", FindSymbol(info));
 
     // We can't unref the library after unload, obviously
     obj.Set("unload", Napi::Function::New(env, UnloadLibrary, "unload", (void *)lib->Ref()));
 
-#undef ADD_CONVENTION
 #undef ADD_METHOD
 
     return obj;
@@ -2326,7 +2333,6 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     Napi::Object types = InitBaseTypes(env);
     exports.Set("types", types);
 
-    exports.Set("internal", Napi::Boolean::New(env, false));
     exports.Set("version", Napi::String::New(env, RG_STRINGIFY(VERSION)));
 
     return exports;

package/src/koffi/src/ffi.hh

@@ -220,6 +220,9 @@ struct FunctionInfo {
 
     const char *name;
     const char *decorated_name; // Only set for some platforms/calling conventions
+#ifdef _WIN32
+    int ordinal_name = -1;
+#endif
     const LibraryHolder *lib = nullptr;
 
     void *native;

package/src/koffi/src/parser.cc

@@ -40,15 +40,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
         MarkError("You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
     }
-    if (Match("__cdecl")) {
-        out_func->convention = CallConvention::Cdecl;
-    } else if (Match("__stdcall")) {
-        out_func->convention = CallConvention::Stdcall;
-    } else if (Match("__fastcall")) {
-        out_func->convention = CallConvention::Fastcall;
-    } else if (Match("__thiscall")) {
-        out_func->convention = CallConvention::Thiscall;
-    }
+    offset += (offset < tokens.len && DetectCallConvention(tokens[offset], &out_func->convention));
     out_func->name = ParseIdentifier();
 
     Consume("(");

package/src/koffi/src/util.cc

@@ -139,6 +139,8 @@ const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
                 bucket->key = DuplicateString(str.c_str(), &instance->str_alloc).ptr;
                 bucket->value = type;
             }
+        } else if (out_directions) {
+            *out_directions = 1;
         }
 
         return type;
@@ -1506,6 +1508,25 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
     return wrapper;
 }
 
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention)
+{
+    if (name == "__cdecl") {
+        *out_convention = CallConvention::Cdecl;
+        return true;
+    } else if (name == "__stdcall") {
+        *out_convention = CallConvention::Stdcall;
+        return true;
+    } else if (name == "__fastcall") {
+        *out_convention = CallConvention::Fastcall;
+        return true;
+    } else if (name == "__thiscall") {
+        *out_convention = CallConvention::Thiscall;
+        return true;
+    } else {
+        return false;
+    }
+}
+
 static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
     if (type->primitive == PrimitiveKind::Record) {

package/src/koffi/src/util.hh

@@ -208,6 +208,8 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
+
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
 void DumpMemory(const char *type, Span<const uint8_t> bytes);