koffi 0.9.33 → 0.9.36

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] == '_';
+}
+
+}

package/src/parser.hh

@@ -0,0 +1,63 @@
+// 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/.
+
+#pragma once
+
+#include "vendor/libcc/libcc.hh"
+#include "util.hh"
+
+#include <napi.h>
+
+namespace RG {
+
+struct InstanceData;
+struct TypeInfo;
+struct FunctionInfo;
+
+class PrototypeParser {
+    Napi::Env env;
+    InstanceData *instance;
+
+    // All these members are relevant to the current parse only, and get resetted each time
+    HeapArray<Span<const char>> tokens;
+    Size offset;
+    bool valid;
+
+public:
+    PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
+
+    bool Parse(Napi::String proto, FunctionInfo *func);
+
+private:
+    void Tokenize(const char *str);
+
+    const TypeInfo *ParseType();
+    const char *ParseIdentifier();
+
+    bool Consume(const char *expect);
+    bool Match(const char *expect);
+
+    bool IsIdentifier(Span<const char> tok) const;
+
+    template <typename... Args>
+    void MarkError(const char *fmt, Args... args)
+    {
+        if (valid) {
+            ThrowError<Napi::Error>(env, fmt, args...);
+            valid = false;
+        }
+        valid = false;
+    }
+};
+
+}

package/src/util.cc

@@ -54,6 +54,29 @@ const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int
     }
 }
 
+const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *ref)
+{
+    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);
+    }
+
+    return type;
+}
+
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
     for (const TypeInfo &type: instance->types) {

package/src/util.hh

@@ -20,6 +20,8 @@
 namespace RG {
 
 struct InstanceData;
+struct TypeInfo;
+struct FunctionInfo;
 
 template <typename T, typename... Args>
 void ThrowError(Napi::Env env, const char *msg, Args... args)
@@ -52,6 +54,7 @@ static inline T *AlignDown(T *ptr, Size align)
 }
 
 const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions = nullptr);
+const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *type);
 
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);

package/test/registry/machines.json

@@ -21,6 +21,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "Linux ARM32": {
+                "directory": "/home/debian/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "Linux ARM32": {
                 "directory": "/home/debian/luigi",
@@ -58,6 +65,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "Linux ARM64": {
+                "directory": "/home/debian/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "Linux ARM64": {
                 "directory": "/home/debian/luigi",
@@ -95,6 +109,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "Linux i386": {
+                "directory": "/home/debian/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "Linux i386": {
                 "directory": "/home/debian/luigi",
@@ -132,6 +153,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "Linux x64": {
+                "directory": "/home/debian/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "Linux x64": {
                 "directory": "/home/debian/luigi",
@@ -169,6 +197,20 @@
             "shutdown": "shutdown -s -t 0"
         },
 
+        "builds": {
+            "Windows i386": {
+                "arch": "ia32",
+                "directory": "C:/Users/windows/Desktop/luigi32",
+                "build": "C:\\Node32\\node32.cmd node ../cnoke/cnoke.js"
+            },
+
+            "Windows x64": {
+                "arch": "x64",
+                "directory": "C:/Users/windows/Desktop/luigi64",
+                "build": "C:\\Node64\\node64.cmd node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "Windows i386": {
                 "directory": "C:/Users/windows/Desktop/luigi32",
@@ -218,6 +260,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "FreeBSD x64": {
+                "directory": "/home/freebsd/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "FreeBSD x64": {
                 "directory": "/home/freebsd/luigi",
@@ -255,6 +304,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "FreeBSD i386": {
+                "directory": "/home/freebsd/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "FreeBSD i386": {
                 "directory": "/home/freebsd/luigi",
@@ -292,6 +348,13 @@
             "shutdown": "sudo poweroff"
         },
 
+        "builds": {
+            "FreeBSD ARM64": {
+                "directory": "/home/freebsd/luigi",
+                "build": "node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "FreeBSD ARM64": {
                 "directory": "/home/freebsd/luigi",
@@ -329,6 +392,13 @@
             "shutdown": "sudo shutdown -h now"
         },
 
+        "builds": {
+            "macOS x64": {
+                "directory": "/Users/macos/luigi",
+                "build": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js"
+            }
+        },
+
         "tests": {
             "macOS x64": {
                 "directory": "/Users/macos/luigi",

package/test/test.js

@@ -24,6 +24,7 @@ const { spawn, spawnSync } = require('child_process');
 const { NodeSSH } = require('node-ssh');
 const chalk = require('chalk');
 const minimatch = require('minimatch');
+const tar = require('tar');
 
 // Globals
 
@@ -56,6 +57,7 @@ async function main() {
 
         if (process.argv.length >= 3 && process.argv[2][0] != '-') {
             switch (process.argv[2]) {
+                case 'build': { command = build; i++ } break;
                 case 'test': { command = test; i++; } break;
                 case 'start': { command = start; i++; } break;
                 case 'stop': { command = stop; i++; } break;
@@ -261,10 +263,109 @@ async function start(detach = true) {
     return success;
 }
 
-async function test() {
+async function build() {
+    let success = true;
+
+    success &= await start(false);
+    success &= await copy(machine => Object.values(machine.builds).map(build => build.directory));
+
+    console.log('>> Run build commands...');
+    await Promise.all(machines.map(async machine => {
+        if (ignore.has(machine))
+            return;
+
+        await Promise.all(Object.keys(machine.builds).map(async suite => {
+            let build = machine.builds[suite];
+
+            let cmd = build.build;
+            let cwd = build.directory + '/koffi';
+
+            let start = process.hrtime.bigint();
+            let ret = await exec_remote(machine, cmd, cwd);
+            let time = Number((process.hrtime.bigint() - start) / 1000000n);
+
+            if (ret.code == 0) {
+                log(machine, `${suite} > Build`, chalk.bold.green(`[${(time / 1000).toFixed(2)}s]`));
+            } else {
+                log(machine, `${suite} > Build`, chalk.bold.red('[error]'));
+
+                if (ret.stdout || ret.stderr)
+                    console.error('');
+
+                let align = log.align + 9;
+                if (ret.stdout) {
+                    let str = ' '.repeat(align) + 'Standard output:\n' +
+                              chalk.yellow(ret.stdout.replace(/^/gm, ' '.repeat(align + 4))) + '\n';
+                    console.error(str);
+                }
+                if (ret.stderr) {
+                    let str = ' '.repeat(align) + 'Standard error:\n' +
+                              chalk.yellow(ret.stderr.replace(/^/gm, ' '.repeat(align + 4))) + '\n';
+                    console.error(str);
+                }
+
+                success = false;
+            }
+        }));
+    }));
+
+    console.log('>> Get build artifacts');
+    {
+        let json = fs.readFileSync(root_dir + '/koffi/package.json', { encoding: 'utf-8' });
+        let version = JSON.parse(json).version;
+
+        await Promise.all(machines.map(async machine => {
+            if (ignore.has(machine))
+                return;
+
+            let copied = true;
+
+            await Promise.all(Object.keys(machine.builds).map(async suite => {
+                let build = machine.builds[suite];
+
+                let platform = build.platform || machine.info.platform;
+                let arch = build.arch || machine.info.arch;
+
+                let src_dir = build.directory + '/koffi/build';
+                let dest_dir = root_dir + `/koffi/build/qemu/${version}/koffi_${platform}_${arch}`;
+
+                fs.mkdirSync(dest_dir + '/build', { mode: 0o755, recursive: true });
+
+                try {
+                    await machine.ssh.getDirectory(dest_dir + '/build', src_dir, {
+                        recursive: false,
+                        concurrency: 4
+                    });
+
+                    tar.c({
+                        gzip: true,
+                        file: dest_dir + '.tar.gz',
+                        sync: true,
+                        cwd: dest_dir + '/..'
+                    }, [path.basename(dest_dir)]);
+                } catch (err) {
+                    console.log(err);
+                    ignore.add(machine);
+                    success = false;
+                    copied = false;
+                }
+            }));
+
+            let status = copied ? chalk.bold.green('[ok]') : chalk.bold.red('[error]');
+            log(machine, 'Download', status);
+        }));
+    }
+
+    if (machines.some(machine => machine.started))
+        success &= await stop(false);
+
+    return success;
+}
+
+async function copy(func) {
     let success = true;
 
-    let snapshot_dir = fs.mkdtempSync(path.join(os.tmpdir(), 'luigi-'));
+    let snapshot_dir = fs.mkdtempSync(path.join(os.tmpdir(), 'luigi_'));
     process.on('exit', () => unlink_recursive(snapshot_dir));
 
     console.log('>> Snapshot code...');
@@ -279,8 +380,6 @@ async function test() {
                basename !== 'luiggi';
     });
 
-    success &= await start(false);
-
     console.log('>> Copy source code...');
     await Promise.all(machines.map(async machine => {
         if (ignore.has(machine))
@@ -288,15 +387,15 @@ async function test() {
 
         let copied = true;
 
-        for (let test of Object.values(machine.tests)) {
+        for (let directory of func(machine)) {
             try {
-                await machine.ssh.exec('rm', ['-rf', test.directory]);
+                await machine.ssh.exec('rm', ['-rf', directory]);
             } catch (err) {
                 // Fails often on Windows (busy directory or whatever), but rarely a problem
             }
 
             try {
-                await machine.ssh.putDirectory(snapshot_dir, test.directory, {
+                await machine.ssh.putDirectory(snapshot_dir, directory, {
                     recursive: true,
                     concurrency: 4
                 });
@@ -311,6 +410,15 @@ async function test() {
         log(machine, 'Copy', status);
     }));
 
+    return success;
+}
+
+async function test() {
+    let success = true;
+
+    success &= await start(false);
+    success &= await copy(machine => Object.values(machine.tests).map(test => test.directory));
+
     console.log('>> Run test commands...');
     await Promise.all(machines.map(async machine => {
         if (ignore.has(machine))