koffi 2.12.4 → 2.12.5-beta.2

package/doc/pages/contribute.md

@@ -123,7 +123,7 @@ node qemu.js info debian_x64
 
 First, you must update the code in three steps:
 
-- Change the version numbers in `package.json` (version and stable for stable releases)
+- Change the version number in `package.json`
 - Add an entry to `CHANGELOG` to summarize the changes since last release
 - Commit theses changes with the message *Bump Koffi to X.Y.Z*
 

package/index.d.ts

@@ -82,14 +82,14 @@ export interface IKoffiLib {
     unload(): void;
 }
 
-export function struct(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
+export function struct(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function struct(ref: IKoffiCType, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function struct(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
-export function pack(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
+export function pack(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function pack(ref: IKoffiCType, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function pack(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 
-export function union(name: string, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
+export function union(name: string | null | undefined, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function union(ref: IKoffiCType, def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 export function union(def: Record<string, TypeSpecWithAlignment>): IKoffiCType;
 
@@ -100,28 +100,34 @@ export class Union {
 
 export function array(ref: TypeSpec, len: number, hint?: ArrayHint | null): IKoffiCType;
 
-export function opaque(name: string): IKoffiCType;
+export function opaque(name: string | null | undefined): IKoffiCType;
 export function opaque(): IKoffiCType;
-/** @deprecated */ export function handle(name: string): IKoffiCType;
+/** @deprecated */ export function handle(name: string | null | undefined): IKoffiCType;
 /** @deprecated */ export function handle(): IKoffiCType;
 
 export function pointer(ref: TypeSpec): IKoffiCType;
-export function pointer(ref: TypeSpec, asteriskCount?: number): IKoffiCType;
-export function pointer(name: string, ref: TypeSpec, asteriskCount?: number): IKoffiCType;
+export function pointer(ref: TypeSpec, count: number): IKoffiCType;
+export function pointer(name: string | null | undefined, ref: TypeSpec): IKoffiCType;
+export function pointer(name: string | null | undefined, ref: TypeSpec, count: number): IKoffiCType;
 
 export function out(type: TypeSpec): IKoffiCType;
 export function inout(type: TypeSpec): IKoffiCType;
 
 export function disposable(type: TypeSpec): IKoffiCType;
-export function disposable(name: string, type: TypeSpec): IKoffiCType;
-export function disposable(name: string, type: TypeSpec, freeFunction: Function): IKoffiCType;
+export function disposable(type: TypeSpec, freeFunction: Function): IKoffiCType;
+export function disposable(name: string | null | undefined, type: TypeSpec): IKoffiCType;
+export function disposable(name: string | null | undefined, type: TypeSpec, freeFunction: Function): IKoffiCType;
 
 export function proto(definition: string): IKoffiCType;
-export function proto(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
-export function proto(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+export function proto(result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+export function proto(convention: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+export function proto(name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+export function proto(convention: string, name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
 /** @deprecated */ export function callback(definition: string): IKoffiCType;
-/** @deprecated */ export function callback(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
-/** @deprecated */ export function callback(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+/** @deprecated */ export function callback(result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+/** @deprecated */ export function callback(convention: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+/** @deprecated */ export function callback(name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+/** @deprecated */ export function callback(convention: string, name: string | null | undefined, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
 
 export function register(callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
 export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;

package/index.js

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// bin/Koffi/package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -397,13 +397,12 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// bin/Koffi/package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.12.4",
-      stable: "2.12.4",
+      version: "2.12.5-beta.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -444,9 +443,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// bin/Koffi/package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -529,7 +528,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/index.js
+// bin/Koffi/package/src/koffi/index.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var native2 = null;

package/indirect.js

@@ -4,9 +4,9 @@ var __commonJS = (cb, mod3) => function __require() {
   return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
-// ../../bin/Koffi/package/src/cnoke/src/tools.js
+// bin/Koffi/package/src/cnoke/src/tools.js
 var require_tools = __commonJS({
-  "../../bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
+  "bin/Koffi/package/src/cnoke/src/tools.js"(exports2, module2) {
     "use strict";
     var crypto = require("crypto");
     var fs2 = require("fs");
@@ -397,13 +397,12 @@ var require_tools = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/package.json
+// bin/Koffi/package/src/koffi/package.json
 var require_package = __commonJS({
-  "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
+  "bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.12.4",
-      stable: "2.12.4",
+      version: "2.12.5-beta.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -444,9 +443,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/src/init.js
+// bin/Koffi/package/src/koffi/src/init.js
 var require_init = __commonJS({
-  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+  "bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
     var fs = require("fs");
     var path = require("path");
     var util = require("util");
@@ -529,7 +528,7 @@ var require_init = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/indirect.js
+// bin/Koffi/package/src/koffi/indirect.js
 var { detect: detect2, init: init2 } = require_init();
 var triplet2 = detect2();
 var mod2 = init2(triplet2, null);

package/package.json

@@ -1,7 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.12.4",
-    "stable": "2.12.4",
+    "version": "2.12.5-beta.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/koffi/src/ffi.cc

@@ -242,24 +242,25 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         return env.Null();
     }
 
-    bool named = info.Length() > 1;
+    bool skip = (info.Length() > 1);
+    bool named = skip && !IsNullOrUndefined(info[0]);
     bool redefine = named && CheckValueTag(instance, info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[named])) {
+    if (!IsObject(info[skip])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
 
     Napi::String name = info[0].As<Napi::String>();
-    Napi::Object obj = info[named].As<Napi::Object>();
+    Napi::Object obj = info[skip].As<Napi::Object>();
     Napi::Array keys = GetOwnPropertyNames(obj);
 
     RG_DEFER_NC(err_guard, count = instance->types.count) {
-        Size start = count + !named;
+        Size start = count + !skip;
 
         for (Size i = start; i < instance->types.count; i++) {
             const TypeInfo *it = &instance->types[i];
@@ -409,24 +410,25 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    bool named = info.Length() > 1;
+    bool skip = (info.Length() > 1);
+    bool named = skip && !IsNullOrUndefined(info[0]);
     bool redefine = named && CheckValueTag(instance, info[0], &TypeInfoMarker);
 
     if (named && !info[0].IsString() && !redefine) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
         return env.Null();
     }
-    if (!IsObject(info[named])) {
+    if (!IsObject(info[skip])) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for members, expected object", GetValueType(instance, info[1]));
         return env.Null();
     }
 
     Napi::String name = info[0].As<Napi::String>();
-    Napi::Object obj = info[named].As<Napi::Object>();
+    Napi::Object obj = info[skip].As<Napi::Object>();
     Napi::Array keys = GetOwnPropertyNames(obj);
 
     RG_DEFER_NC(err_guard, count = instance->types.count) {
-        Size start = count + !named;
+        Size start = count + !skip;
 
         for (Size i = start; i < instance->types.count; i++) {
             const TypeInfo *it = &instance->types[i];
@@ -584,7 +586,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    bool named = (info.Length() >= 1);
+    bool named = (info.Length() >= 1) && !IsNullOrUndefined(info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -621,7 +623,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    bool named = (info.Length() >= 2 && !info[1].IsNumber());
+    bool skip = (info.Length() > 1) && !info[1].IsNumber();
+    bool named = skip && !IsNullOrUndefined(info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -630,18 +633,18 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
 
     std::string name = named ? info[0].As<Napi::String>() : std::string();
 
-    const TypeInfo *type = ResolveType(info[named]);
+    const TypeInfo *type = ResolveType(info[skip]);
     if (!type)
         return env.Null();
 
     int count = 0;
-    if (info.Length() >= 2u + named) {
-        if (!info[1 + named].IsNumber()) {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for count, expected number", GetValueType(instance, info[1 + named]));
+    if (info.Length() >= 2u + skip) {
+        if (!info[1 + skip].IsNumber()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for count, expected number", GetValueType(instance, info[1 + skip]));
             return env.Null();
         }
 
-        count = info[1 + named].As<Napi::Number>();
+        count = info[1 + skip].As<Napi::Number>();
 
         if (count < 1 || count > 4) {
             ThrowError<Napi::TypeError>(env, "Value of count must be between 1 and 4");
@@ -727,7 +730,8 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    bool named = (info.Length() >= 2 && !info[1].IsFunction());
+    bool skip = (info.Length() > 1) && !info[1].IsFunction();
+    bool named = skip && !IsNullOrUndefined(info[0]);
 
     if (named && !info[0].IsString()) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, info[0]));
@@ -736,7 +740,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
 
     Napi::String name = info[0].As<Napi::String>();
 
-    const TypeInfo *src = ResolveType(info[named]);
+    const TypeInfo *src = ResolveType(info[skip]);
     if (!src)
         return env.Null();
     if (src->primitive != PrimitiveKind::Pointer &&
@@ -753,8 +757,8 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
 
     DisposeFunc *dispose;
     Napi::Function dispose_func;
-    if (info.Length() >= 2u + named && !IsNullOrUndefined(info[1 + named])) {
-        Napi::Function func = info[1 + named].As<Napi::Function>();
+    if (info.Length() >= 2u + skip && !IsNullOrUndefined(info[1 + skip])) {
+        Napi::Function func = info[1 + skip].As<Napi::Function>();
 
         if (!func.IsFunction()) {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value for func, expected function", GetValueType(instance, func));
@@ -989,8 +993,10 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
-static bool ParseClassicFunction(const Napi::CallbackInfo &info, FunctionInfo *out_func)
+static bool ParseClassicFunction(const Napi::CallbackInfo &info, bool concrete, FunctionInfo *out_func)
 {
+    RG_ASSERT(info.Length() >= 2);
+
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
@@ -1000,14 +1006,21 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, FunctionInfo *o
 
     // 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());
+        if (info.Length() < 3) {
+            ThrowError<Napi::TypeError>(env, "Expected 3 or 4 arguments, got %1", info.Length());
             return false;
         }
 
         name = info[1u].As<Napi::String>();
         ret = info[2u];
-        parameters = info[3u].As<Napi::Array>();
+        parameters = (info.Length() >= 4 ? info[3u] : env.Null()).As<Napi::Array>();
+    }
+
+    bool named = parameters.IsArray();
+
+    if (!named) {
+        parameters = ret.As<Napi::Array>();
+        ret = name;
     }
 
 #if defined(_WIN32)
@@ -1017,11 +1030,16 @@ static bool ParseClassicFunction(const Napi::CallbackInfo &info, FunctionInfo *o
     }
 #endif
     if (!name.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
-        return false;
+        if (!concrete && IsNullOrUndefined(name)) {
+            named = false;
+        } else {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
+            return false;
+        }
     }
 
-    out_func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
+    // Leave anonymous naming responsibility to caller
+    out_func->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr : nullptr;
 
     out_func->ret.type = ResolveType(ret);
     if (!out_func->ret.type)
@@ -1085,8 +1103,8 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     FunctionInfo *func = instance->callbacks.AppendDefault();
     RG_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
 
-    if (info.Length() >= 3) {
-        if (!ParseClassicFunction(info, func))
+    if (info.Length() >= 2) {
+        if (!ParseClassicFunction(info, false, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1095,13 +1113,19 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
         }
 
         std::string proto = info[0u].As<Napi::String>();
-        if (!ParsePrototype(env, proto.c_str(), func))
+        if (!ParsePrototype(env, proto.c_str(), false, func))
             return env.Null();
     } else {
-        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 to 4 arguments, got %1", info.Length());
         return env.Null();
     }
 
+    bool named = func->name;
+
+    if (!named) {
+        func->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
+    }
+
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
 
@@ -1112,7 +1136,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     func->required_parameters += 2;
 
     // We cannot fail after this check
-    if (instance->types_map.Find(func->name)) {
+    if (named && instance->types_map.Find(func->name)) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", func->name);
         return env.Null();
     }
@@ -1648,8 +1672,8 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 
     func->lib = lib->Ref();
 
-    if (info.Length() >= 3) {
-        if (!ParseClassicFunction(info, func))
+    if (info.Length() >= 2) {
+        if (!ParseClassicFunction(info, true, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1658,10 +1682,10 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
         }
 
         std::string proto = info[0u].As<Napi::String>();
-        if (!ParsePrototype(env, proto.c_str(), func))
+        if (!ParsePrototype(env, proto.c_str(), true, func))
             return env.Null();
     } else {
-        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 to 4 arguments, got %1", info.Length());
         return env.Null();
     }
 

package/src/koffi/src/parser.cc

@@ -27,7 +27,7 @@
 
 namespace RG {
 
-bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
+bool PrototypeParser::Parse(const char *str, bool concrete, FunctionInfo *out_func)
 {
     tokens.Clear();
     offset = 0;
@@ -41,7 +41,21 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
         return false;
     }
     offset += (offset < tokens.len && DetectCallConvention(tokens[offset], &out_func->convention));
-    out_func->name = ParseIdentifier();
+
+    if (offset >= tokens.len) {
+        MarkError("Unexpected end of prototype, expected identifier");
+        return false;
+    }
+    if (IsIdentifier(tokens[offset])) {
+        Span<const char> tok = tokens[offset++];
+        out_func->name = DuplicateString(tok, &instance->str_alloc).ptr;
+    } else if (!concrete) {
+        // Leave anonymous naming responsibility to caller
+        out_func->name = nullptr;
+    } else {
+        MarkError("Unexpected token '%1', expected identifier", tokens[offset]);
+        return false;
+    }
 
     Consume("(");
     offset += (offset + 1 < tokens.len && tokens[offset] == "void" && tokens[offset + 1] == ")");
@@ -169,23 +183,6 @@ const TypeInfo *PrototypeParser::ParseType(int *out_directions)
     return instance->void_type;
 }
 
-const char *PrototypeParser::ParseIdentifier()
-{
-    if (offset >= tokens.len) {
-        MarkError("Unexpected end of prototype, expected identifier");
-        return "";
-    }
-    if (!IsIdentifier(tokens[offset])) {
-        MarkError("Unexpected token '%1', expected identifier", tokens[offset]);
-        return "";
-    }
-
-    Span<const char> tok = tokens[offset++];
-    const char *ident = DuplicateString(tok, &instance->str_alloc).ptr;
-
-    return ident;
-}
-
 bool PrototypeParser::Consume(const char *expect)
 {
     if (offset >= tokens.len) {
@@ -217,10 +214,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)
+bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func)
 {
     PrototypeParser parser(env);
-    return parser.Parse(str, out_func);
+    return parser.Parse(str, concrete, out_func);
 }
 
 }

package/src/koffi/src/parser.hh

@@ -44,13 +44,12 @@ class PrototypeParser {
 public:
     PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
 
-    bool Parse(const char *str, FunctionInfo *out_func);
+    bool Parse(const char *str, bool concrete, FunctionInfo *out_func);
 
 private:
     void Tokenize(const char *str);
 
     const TypeInfo *ParseType(int *out_directions);
-    const char *ParseIdentifier();
 
     bool Consume(const char *expect);
     bool Match(const char *expect);
@@ -68,6 +67,6 @@ private:
     }
 };
 
-bool ParsePrototype(Napi::Env env, const char *str, FunctionInfo *out_func);
+bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func);
 
 }