koffi 0.9.34 → 0.9.37

package/CMakeLists.txt

@@ -30,6 +30,7 @@ set(KOFFI_SRC
     src/call_x64_win.cc
     src/call_x86.cc
     src/ffi.cc
+    src/parser.cc
     src/util.cc
     vendor/libcc/libcc.cc
 )
@@ -54,7 +55,7 @@ endif()
 add_node_addon(NAME koffi SOURCES ${KOFFI_SRC})
 target_include_directories(koffi PRIVATE . vendor/node-addon-api)
 
-target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS)
+target_compile_definitions(koffi PRIVATE FELIX_TARGET=koffi NAPI_DISABLE_CPP_EXCEPTIONS NAPI_VERSION=8)
 if(WIN32)
     target_compile_definitions(koffi PRIVATE _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_DEPRECATE)
     target_link_libraries(koffi PRIVATE ws2_32)

package/README.md

@@ -196,17 +196,20 @@ const Font = koffi.struct('Font', {
 // Fix the path to Raylib DLL if needed
 let lib = koffi.load('build/raylib' + koffi.extension);
 
-const InitWindow = lib.cdecl('InitWindow', 'void', ['int', 'int', 'string']);
-const SetTargetFPS = lib.cdecl('SetTargetFPS', 'void', ['int']);
-const GetScreenWidth = lib.cdecl('GetScreenWidth', 'int', []);
-const GetScreenHeight = lib.cdecl('GetScreenHeight', 'int', []);
-const ClearBackground = lib.cdecl('ClearBackground', 'void', [Color]);
-const BeginDrawing = lib.cdecl('BeginDrawing', 'void', []);
-const EndDrawing = lib.cdecl('EndDrawing', 'void', []);
-const WindowShouldClose = lib.cdecl('WindowShouldClose', 'bool', []);
-const GetFontDefault = lib.cdecl('GetFontDefault', Font, []);
-const MeasureTextEx = lib.cdecl('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
-const DrawTextEx = lib.cdecl('DrawTextEx', 'void', [Font, 'string', Vector2, 'float', 'float', Color]);
+// Classic function declaration
+const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'string']);
+const SetTargetFPS = lib.func('SetTargetFPS', 'void', ['int']);
+const GetScreenWidth = lib.func('GetScreenWidth', 'int', []);
+const GetScreenHeight = lib.func('GetScreenHeight', 'int', []);
+const ClearBackground = lib.func('ClearBackground', 'void', [Color]);
+
+// Prototype parser
+const BeginDrawing = lib.func('void BeginDrawing()');
+const EndDrawing = lib.func('void EndDrawing()');
+const WindowShouldClose = lib.func('void WindowShouldClose(bool)');
+const GetFontDefault = lib.func('Font GetFontDefault()');
+const MeasureTextEx = lib.func('Vector2 MeasureTextEx(Font, const char *, float, float)');
+const DrawTextEx = lib.func('void DrawTextEx(Font font, const char *text, Vector2 pos, float size, float spacing, Color tint)');
 
 InitWindow(800, 600, 'Test Raylib');
 SetTargetFPS(60);
@@ -260,13 +263,13 @@ MessageBoxA(null, 'Hello', 'Foobar', MB_ICONINFORMATION);
 
 Koffi is tested on multiple architectures using emulated (accelerated when possible) QEMU machines. First, you need to install qemu packages, such as `qemu-system` (or even `qemu-system-gui`) on Ubuntu.
 
-These machines are not included directly in this repository (for license and size reasons), but they are available here: https://koromix.dev/files/koffi/
+These machines are not included directly in this repository (for license and size reasons), but they are available here: https://koromix.dev/files/koffi/machines/
 
 For example, if you want to run the tests on Debian ARM64, run the following commands:
 
 ```sh
 cd luigi/koffi/test/
-wget -q -O- https://koromix.dev/files/koffi/qemu_debian_arm64.tar.zst | zstd -d | tar xv
+wget -q -O- https://koromix.dev/files/koffi/machines/qemu_debian_arm64.tar.zst | zstd -d | tar xv
 sha256sum -c --ignore-missing registry/sha256sum.txt
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "0.9.34",
+  "version": "0.9.37",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -18,12 +18,12 @@
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
   "main": "src/index.js",
   "scripts": {
-    "install": "cnoke",
+    "install": "cnoke --prebuild https://koromix.dev/files/koffi/builds/{{version}}/koffi_{{platform}}_{{arch}}.tar.gz",
     "test": "node test/test.js"
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^1.0.1"
+    "cnoke": "^1.0.4"
   },
   "devDependencies": {
     "chalk": "^4.1.2",
@@ -31,7 +31,8 @@
     "minimatch": "^5.0.1",
     "node-ssh": "^12.0.3",
     "ref-napi": "^3.0.3",
-    "ref-struct-di": "^1.1.1"
+    "ref-struct-di": "^1.1.1",
+    "tar": "^6.1.11"
   },
   "files": [
     "src",

package/src/call_arm32.cc

@@ -394,8 +394,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_arm64.cc

@@ -353,8 +353,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x64_sysv.cc

@@ -323,8 +323,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x64_win.cc

@@ -157,8 +157,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/call_x86.cc

@@ -65,7 +65,7 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
     func->args_size = params_size + 4 * !func->ret.trivial;
 
     switch (func->convention) {
-        case CallConvention::Default: {
+        case CallConvention::Cdecl: {
             func->decorated_name = Fmt(&instance->str_alloc, "_%1", func->name).ptr;
         } break;
         case CallConvention::Stdcall: {
@@ -201,8 +201,12 @@ Napi::Value TranslateCall(InstanceData *instance, const FunctionInfo *func, cons
                     if (RG_UNLIKELY(!call.AllocHeap(param.type->ref->size, 16, &ptr)))
                         return env.Null();
 
-                    if ((param.directions & 1) && !call.PushObject(obj, param.type->ref, ptr))
-                        return env.Null();
+                    if (param.directions & 1) {
+                        if (!call.PushObject(obj, param.type->ref, ptr))
+                            return env.Null();
+                    } else {
+                        memset(ptr, 0, param.type->size);
+                    }
                     if (param.directions & 2) {
                         OutObject out = {obj, ptr, param.type->ref};
                         out_objects.Append(out);

package/src/ffi.cc

@@ -14,6 +14,7 @@
 #include "vendor/libcc/libcc.hh"
 #include "ffi.hh"
 #include "call.hh"
+#include "parser.hh"
 #include "util.hh"
 
 #ifdef _WIN32
@@ -182,23 +183,8 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     if (!ref)
         return env.Null();
 
-    char name_buf[256];
-    Fmt(name_buf, "%1%2*", ref->name, ref->primitive == PrimitiveKind::Pointer ? "" : " ");
-
-    TypeInfo *type = instance->types_map.FindValue(name_buf, nullptr);
-
-    if (!type) {
-        type = instance->types.AppendDefault();
-
-        type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
-
-        type->primitive = PrimitiveKind::Pointer;
-        type->size = RG_SIZE(void *);
-        type->align = RG_SIZE(void *);
-        type->ref = ref;
-
-        instance->types_map.Set(type);
-    }
+    TypeInfo *type = (TypeInfo *)GetPointerType(instance, ref);
+    RG_ASSERT(type);
 
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
     SetValueTag(instance, external, &TypeInfoMarker);
@@ -316,38 +302,33 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     return TranslateCall(instance, &func, info);
 }
 
-static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention, bool variadic)
+static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
+                                 Napi::Array parameters, FunctionInfo *func)
 {
-    Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-    LibraryHolder *lib = (LibraryHolder *)info.Data();
 
-    if (info.Length() < 3) {
-        ThrowError<Napi::TypeError>(env, "Expected 3 or 4 arguments, not %1", info.Length());
-        return env.Null();
+#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 (!info[0].IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for filename, expected string", GetValueType(instance, info[0]));
-        return env.Null();
+#else
+    if (!name.IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
+        return false;
     }
+#endif
 
-    FunctionInfo *func = new FunctionInfo();
-    RG_DEFER_N(func_guard) { delete func; };
-
-    std::string name = ((Napi::Value)info[0u]).As<Napi::String>();
-    func->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
-    func->lib = lib->Ref();
-    func->convention = convention;
+    func->name = DuplicateString(std::string(name).c_str(), &instance->str_alloc).ptr;
 
-    func->ret.type = ResolveType(instance, info[1u]);
+    func->ret.type = ResolveType(instance, ret);
     if (!func->ret.type)
-        return env.Null();
-    if (!((Napi::Value)info[2u]).IsArray()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, (Napi::Value)info[1u]), func->name);
-        return env.Null();
+        return false;
+    if (!parameters.IsArray()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
+        return false;
     }
 
-    Napi::Array parameters = ((Napi::Value)info[2u]).As<Napi::Array>();
     Size parameters_len = parameters.Length();
 
     if (parameters_len) {
@@ -357,11 +338,6 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
             func->variadic = true;
             parameters_len--;
         }
-
-        if (!variadic && func->variadic) {
-            LogError("Call convention '%1' does not support variadic functions, ignoring");
-            func->convention = CallConvention::Default;
-        }
     }
 
     for (uint32_t j = 0; j < parameters_len; j++) {
@@ -369,19 +345,19 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
 
         param.type = ResolveType(instance, parameters[j], &param.directions);
         if (!param.type)
-            return env.Null();
+            return false;
         if (param.type->primitive == PrimitiveKind::Void) {
             ThrowError<Napi::TypeError>(env, "Type void cannot be used as a parameter");
-            return env.Null();
+            return false;
         }
 
         if (func->parameters.len >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
-            return env.Null();
+            return false;
         }
         if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
-            return env.Null();
+            return false;
         }
 
         param.offset = j;
@@ -389,6 +365,40 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         func->parameters.Append(param);
     }
 
+    return true;
+}
+
+static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    LibraryHolder *lib = (LibraryHolder *)info.Data();
+
+    FunctionInfo *func = new FunctionInfo();
+    RG_DEFER_N(func_guard) { delete func; };
+
+    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))
+            return env.Null();
+    } else if (info.Length() >= 1) {
+        PrototypeParser parser(env);
+
+        if (!parser.Parse(info[0u].As<Napi::String>(), func))
+            return env.Null();
+    } else {
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
+        return env.Null();
+    }
+
+    if (func->convention != CallConvention::Cdecl && func->variadic) {
+        LogError("Call convention '%1' does not support variadic functions, ignoring",
+                 CallConventionNames[(int)func->convention]);
+        func->convention = CallConvention::Cdecl;
+    }
+
     if (!AnalyseFunction(instance, func))
         return env.Null();
     if (func->variadic) {
@@ -397,11 +407,18 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
 #ifdef _WIN32
-    if (func->decorated_name) {
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
-    }
-    if (!func->func) {
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, func->name);
+    if (info[0].IsString()) {
+        if (func->decorated_name) {
+            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
+        }
+        if (!func->func) {
+            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->name);
+        }
+    } else {
+        uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
+
+        func->decorated_name = nullptr;
+        func->func = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)ordinal);
     }
 #else
     if (func->decorated_name) {
@@ -417,7 +434,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
     Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, name.c_str(), (void *)func);
+    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func);
     wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { delete func; }, func);
     func_guard.Disable();
 
@@ -481,17 +498,18 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
 
     Napi::Object obj = Napi::Object::New(env);
 
-#define ADD_CONVENTION(Name, Value, Variadic) \
+#define ADD_CONVENTION(Name, Value) \
         do { \
-            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value), (Variadic)); }; \
+            const auto wrapper = [](const Napi::CallbackInfo &info) { return FindLibraryFunction(info, (Value)); }; \
             Napi::Function func = Napi::Function::New(env, wrapper, (Name), (void *)lib->Ref()); \
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
 
-    ADD_CONVENTION("cdecl", CallConvention::Default, true);
-    ADD_CONVENTION("stdcall", CallConvention::Stdcall, false);
-    ADD_CONVENTION("fastcall", CallConvention::Fastcall, false);
+    ADD_CONVENTION("func", CallConvention::Cdecl);
+    ADD_CONVENTION("cdecl", CallConvention::Cdecl);
+    ADD_CONVENTION("stdcall", CallConvention::Stdcall);
+    ADD_CONVENTION("fastcall", CallConvention::Fastcall);
 
 #undef ADD_CONVENTION
 

package/src/ffi.hh

@@ -100,12 +100,12 @@ struct LibraryHolder {
 };
 
 enum class CallConvention {
-    Default,
+    Cdecl,
     Stdcall,
     Fastcall
 };
 static const char *const CallConventionNames[] = {
-    "Default",
+    "Cdecl",
     "Stdcall",
     "Fastcall"
 };

package/src/parser.cc

@@ -0,0 +1,246 @@
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+#include "vendor/libcc/libcc.hh"
+#include "ffi.hh"
+#include "parser.hh"
+
+#include <napi.h>
+
+namespace RG {
+
+bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
+{
+    if (!proto.IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, proto));
+        return false;
+    }
+
+    tokens.Clear();
+    offset = 0;
+    valid = true;
+
+    Tokenize(std::string(proto).c_str());
+
+    func->ret.type = ParseType();
+    if (Match("__cdecl")) {
+        func->convention = CallConvention::Cdecl;
+    } else if (Match("__stdcall")) {
+        func->convention = CallConvention::Stdcall;
+    } else if (Match("__fastcall")) {
+        func->convention = CallConvention::Fastcall;
+    }
+    func->name = ParseIdentifier();
+
+    Consume("(");
+    if (offset < tokens.len && tokens[offset] != ")") {
+        for (;;) {
+            ParameterInfo param = {};
+
+            if (Match("...")) {
+                func->variadic = true;
+                break;
+            }
+
+            if (Match("_In_")) {
+                param.directions = 1;
+            } else if (Match("_Out_")) {
+                param.directions = 2;
+            } else if (Match("_Inout_")) {
+                param.directions = 3;
+            } else {
+                param.directions = 1;
+            }
+
+            param.type = ParseType();
+            if (param.type->primitive == PrimitiveKind::Void) {
+                MarkError("Type void cannot be used as a parameter");
+                return false;
+            }
+
+            if ((param.directions & 2) && (param.type->primitive != PrimitiveKind::Pointer ||
+                                           param.type->ref->primitive != PrimitiveKind::Record)) {
+                MarkError("Only object pointers can be used as out parameters (for now)");
+                return false;
+            }
+
+            offset += (offset < tokens.len && IsIdentifier(tokens[offset]));
+
+            if (func->parameters.len >= MaxParameters) {
+                MarkError("Functions cannot have more than %1 parameters", MaxParameters);
+                return false;
+            }
+            if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
+                MarkError("Functions cannot have more than out %1 parameters", MaxOutParameters);
+                return false;
+            }
+
+            param.offset = func->parameters.len;
+
+            func->parameters.Append(param);
+
+            if (offset >= tokens.len || tokens[offset] != ",")
+                break;
+            offset++;
+        }
+    }
+    Consume(")");
+
+    Match(";");
+    if (offset < tokens.len) {
+        MarkError("Unexpected token '%1' after prototype", tokens[offset]);
+    }
+
+    return valid;
+}
+
+void PrototypeParser::Tokenize(const char *str)
+{
+    for (Size i = 0; str[i]; i++) {
+        char c = str[i];
+
+        if (IsAsciiWhite(c)) {
+            continue;
+        } else if (IsAsciiAlpha(c) || c == '_') {
+            Size j = i;
+            while (str[++j] && (IsAsciiAlphaOrDigit(str[j]) || 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("...");
+            i += 2;
+        } else {
+            Span<const char> tok = MakeSpan(str + i, 1);
+            tokens.Append(tok);
+        }
+    }
+}
+
+const TypeInfo *PrototypeParser::ParseType()
+{
+    HeapArray<char> buf(&instance->str_alloc);
+
+    Size indirect = 0;
+
+    Size start = offset;
+    while (offset < tokens.len && IsIdentifier(tokens[offset])) {
+        Span<const char> tok = tokens[offset++];
+
+        if (tok != "const") {
+            buf.Append(tok);
+            buf.Append(' ');
+        }
+    }
+    if (offset == start) {
+        if (offset < tokens.len) {
+            MarkError("Unexpected token '%1', expected identifier", tokens[offset]);
+        } else {
+            MarkError("Unexpected end of prototype, expected identifier");
+        }
+        return instance->types_map.FindValue("void", nullptr);
+    }
+    while (offset < tokens.len && tokens[offset] == "*") {
+        offset++;
+        indirect++;
+    }
+    buf.ptr[--buf.len] = 0;
+
+    if (TestStr(buf, "char") && indirect) {
+        buf.RemoveFrom(0);
+        Fmt(&buf, "string");
+
+        indirect--;
+    }
+
+    while (buf.len) {
+        const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
+
+        if (type) {
+            for (Size i = 0; i < indirect; i++) {
+                type = GetPointerType(instance, type);
+                RG_ASSERT(type);
+            }
+            return type;
+        }
+
+        // Truncate last token
+        {
+            Span<const char> remain;
+            SplitStrReverse(buf, ' ', &remain);
+            buf.len = remain.len;
+            buf.ptr[buf.len] = 0;
+        }
+
+        if (indirect) {
+            offset -= indirect;
+            indirect = 0;
+        }
+        offset--;
+    }
+
+    MarkError("Unknown type '%1'", tokens[start]);
+    return instance->types_map.FindValue("void", nullptr);
+}
+
+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) {
+        MarkError("Unexpected end of prototype, expected '%1'", expect);
+        return false;
+    }
+    if (tokens[offset] != expect) {
+        MarkError("Unexpected token '%1', expected '%2'", tokens[offset], expect);
+        return false;
+    }
+
+    offset++;
+    return true;
+}
+
+bool PrototypeParser::Match(const char *expect)
+{
+    if (offset < tokens.len && tokens[offset] == expect) {
+        offset++;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool PrototypeParser::IsIdentifier(Span<const char> tok) const
+{
+    RG_ASSERT(tok.len);
+    return IsAsciiAlpha(tok[0]) || tok[0] == '_';
+}
+
+}