koffi 0.9.20 → 0.9.23

package/src/call_x64_sysv.cc

@@ -237,7 +237,8 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(param.gpr_count)) {
                     *(gpr_ptr++) = (uint64_t)b;
                 } else {
-                    *(args_ptr++) = (uint8_t)b;
+                    *args_ptr = (uint8_t)b;
+                    args_ptr += 8;
                 }
             } break;
             case PrimitiveKind::Int8:
@@ -260,7 +261,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 } else {
                     args_ptr = AlignUp(args_ptr, param.type->align);
                     memcpy(args_ptr, &v, param.type->size); // Little Endian
-                    args_ptr += param.type->size;
+                    args_ptr += 8;
                 }
             } break;
             case PrimitiveKind::Float32: {
@@ -276,7 +277,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                 } else {
                     args_ptr = AlignUp(args_ptr, 4);
                     memcpy(args_ptr, &f, 4);
-                    args_ptr += 4;
+                    args_ptr += 8;
                 }
             } break;
             case PrimitiveKind::Float64: {
@@ -387,7 +388,7 @@ static Napi::Value TranslateCall(const Napi::CallbackInfo &info)
                     args_ptr = AlignUp(args_ptr, param.type->align);
                     if (!call.PushObject(obj, param.type, args_ptr))
                         return env.Null();
-                    args_ptr += param.type->size;
+                    args_ptr += AlignLen(param.type->size, 8);
                 }
             } break;
         }

package/src/ffi.cc

@@ -461,7 +461,8 @@ void LibraryHolder::Unref()
     }
 }
 
-static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive, int16_t size)
+static void RegisterPrimitiveType(InstanceData *instance, const char *name, PrimitiveKind primitive,
+                                  int16_t size, int16_t align)
 {
     TypeInfo *type = instance->types.AppendDefault();
 
@@ -469,7 +470,7 @@ static void RegisterPrimitiveType(InstanceData *instance, const char *name, Prim
 
     type->primitive = primitive;
     type->size = size;
-    type->align = size;
+    type->align = align;
 
     RG_ASSERT(!instance->types_map.Find(name));
     instance->types_map.Set(type);
@@ -481,53 +482,47 @@ static Napi::Object InitBaseTypes(Napi::Env env)
 
     RG_ASSERT(!instance->types.len);
 
-    RegisterPrimitiveType(instance, "void", PrimitiveKind::Void, 0);
-    RegisterPrimitiveType(instance, "void *", PrimitiveKind::Pointer, RG_SIZE(void *));
-    RegisterPrimitiveType(instance, "bool", PrimitiveKind::Bool, 1);
-    RegisterPrimitiveType(instance, "int8", PrimitiveKind::Int8, 1);
-    RegisterPrimitiveType(instance, "int8_t", PrimitiveKind::Int8, 1);
-    RegisterPrimitiveType(instance, "uint8", PrimitiveKind::UInt8, 1);
-    RegisterPrimitiveType(instance, "uint8_t", PrimitiveKind::UInt8, 1);
-    RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1);
-    RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1);
-    RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1);
-    RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2);
-    RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2);
-    RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2);
-    RegisterPrimitiveType(instance, "uint16_t", PrimitiveKind::UInt16, 2);
-    RegisterPrimitiveType(instance, "short", PrimitiveKind::Int16, 2);
-    RegisterPrimitiveType(instance, "ushort", PrimitiveKind::UInt16, 2);
-    RegisterPrimitiveType(instance, "unsigned short", PrimitiveKind::UInt16, 2);
-    RegisterPrimitiveType(instance, "int32", PrimitiveKind::Int32, 4);
-    RegisterPrimitiveType(instance, "int32_t", PrimitiveKind::Int32, 4);
-    RegisterPrimitiveType(instance, "uint32", PrimitiveKind::UInt32, 4);
-    RegisterPrimitiveType(instance, "uint32_t", PrimitiveKind::UInt32, 4);
-    RegisterPrimitiveType(instance, "int", PrimitiveKind::Int32, 4);
-    RegisterPrimitiveType(instance, "uint", PrimitiveKind::UInt32, 4);
-    RegisterPrimitiveType(instance, "unsigned int", PrimitiveKind::UInt32, 4);
-    RegisterPrimitiveType(instance, "int64", PrimitiveKind::Int64, 8);
-    RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8);
-    RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8);
-    RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8);
-#if ULONG_MAX == UINT64_MAX
-    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int64, 8);
-    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt64, 8);
-    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, 8);
-#else
-    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int32, 4);
-    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt32, 4);
-    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, 4);
-#endif
-    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, 8);
-    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, 8);
-    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, 8);
-    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, 8);
-    RegisterPrimitiveType(instance, "float32", PrimitiveKind::Float32, 4);
-    RegisterPrimitiveType(instance, "float64", PrimitiveKind::Float64, 8);
-    RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4);
-    RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8);
-    RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *));
-    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *));
+    RegisterPrimitiveType(instance, "void", PrimitiveKind::Void, 0, 0);
+    RegisterPrimitiveType(instance, "void *", PrimitiveKind::Pointer, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "bool", PrimitiveKind::Bool, RG_SIZE(bool), alignof(bool));
+    RegisterPrimitiveType(instance, "int8", PrimitiveKind::Int8, 1, 1);
+    RegisterPrimitiveType(instance, "int8_t", PrimitiveKind::Int8, 1, 1);
+    RegisterPrimitiveType(instance, "uint8", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "uint8_t", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "char", PrimitiveKind::Int8, 1, 1);
+    RegisterPrimitiveType(instance, "uchar", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "unsigned char", PrimitiveKind::UInt8, 1, 1);
+    RegisterPrimitiveType(instance, "int16", PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(instance, "int16_t", PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(instance, "uint16", PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(instance, "uint16_t", PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(instance, "short", PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(instance, "ushort", PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(instance, "unsigned short", PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(instance, "int32", PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(instance, "int32_t", PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(instance, "uint32", PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(instance, "uint32_t", PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(instance, "int", PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(instance, "uint", PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(instance, "unsigned int", PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(instance, "int64", PrimitiveKind::Int64, 8, alignof(int64_t));
+    RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8, alignof(int64_t));
+    RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8, alignof(int64_t));
+    RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8, alignof(int64_t));
+    RegisterPrimitiveType(instance, "long", PrimitiveKind::Int64, RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "ulong", PrimitiveKind::UInt64, RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "unsigned long", PrimitiveKind::UInt64, RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(long long), alignof(long long));
+    RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(long long), alignof(long long));
+    RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(long long), alignof(long long));
+    RegisterPrimitiveType(instance, "unsigned long long", PrimitiveKind::UInt64, RG_SIZE(long long), alignof(long long));
+    RegisterPrimitiveType(instance, "float32", PrimitiveKind::Float32, 4, alignof(float));
+    RegisterPrimitiveType(instance, "float64", PrimitiveKind::Float64, 8, alignof(double));
+    RegisterPrimitiveType(instance, "float", PrimitiveKind::Float32, 4, alignof(float));
+    RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
+    RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {
@@ -566,6 +561,30 @@ InstanceData::InstanceData()
     heap_mem.ptr = (uint8_t *)Allocator::Allocate(&mem_alloc, heap_mem.len);
 }
 
+template <typename Func>
+static void SetExports(Napi::Env env, Func func)
+{
+    func("struct", Napi::Function::New(env, CreateStructType));
+    func("handle", Napi::Function::New(env, CreateHandleType));
+    func("pointer", Napi::Function::New(env, CreatePointerType));
+    func("load", Napi::Function::New(env, LoadSharedLibrary));
+    func("in", Napi::Function::New(env, MarkIn));
+    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__)
+    func("extension", Napi::String::New(env, ".dylib"));
+#else
+    func("extension", Napi::String::New(env, ".so"));
+#endif
+
+    Napi::Object types = InitBaseTypes(env);
+    func("types", types);
+}
+
 }
 
 #if NODE_WANT_INTERNALS
@@ -604,25 +623,7 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
     instance->debug = GetDebugFlag("DUMP_CALLS");
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
-    SetValue(env, target, "struct", Napi::Function::New(env_napi, CreateStructType));
-    SetValue(env, target, "handle", Napi::Function::New(env_napi, CreateHandleType));
-    SetValue(env, target, "pointer", Napi::Function::New(env_napi, CreatePointerType));
-    SetValue(env, target, "load", Napi::Function::New(env_napi, LoadSharedLibrary));
-    SetValue(env, target, "in", Napi::Function::New(env_napi, MarkIn));
-    SetValue(env, target, "out", Napi::Function::New(env_napi, MarkOut));
-    SetValue(env, target, "inout", Napi::Function::New(env_napi, MarkInOut));
-
-    SetValue(env, target, "internal", Napi::Boolean::New(env_napi, true));
-#if defined(_WIN32)
-    SetValue(env, target, "extension", Napi::String::New(env_napi, ".dll"));
-#elif defined(__APPLE__)
-    SetValue(env, target, "extension", Napi::String::New(env_napi, ".dylib"));
-#else
-    SetValue(env, target, "extension", Napi::String::New(env_napi, ".so"));
-#endif
-
-    Napi::Object types = InitBaseTypes(env_cxx);
-    SetValue(env, target, "types", types);
+    SetExports(env_napi, [&](const char *name, Napi::Value value) { SetValue(env, target, name, value); });
 }
 
 #else
@@ -637,25 +638,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     instance->debug = GetDebugFlag("DUMP_CALLS");
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
-    exports.Set("struct", Napi::Function::New(env, CreateStructType));
-    exports.Set("handle", Napi::Function::New(env, CreateHandleType));
-    exports.Set("pointer", Napi::Function::New(env, CreatePointerType));
-    exports.Set("load", Napi::Function::New(env, LoadSharedLibrary));
-    exports.Set("in", Napi::Function::New(env, MarkIn));
-    exports.Set("out", Napi::Function::New(env, MarkOut));
-    exports.Set("inout", Napi::Function::New(env, MarkInOut));
-
-    exports.Set("internal", Napi::Boolean::New(env, false));
-#if defined(_WIN32)
-    exports.Set("extension", Napi::String::New(env, ".dll"));
-#elif defined(__APPLE__)
-    exports.Set("extension", Napi::String::New(env, ".dylib"));
-#else
-    exports.Set("extension", Napi::String::New(env, ".so"));
-#endif
-
-    Napi::Object types = InitBaseTypes(env);
-    exports.Set("types", types);
+    SetExports(env, [&](const char *name, Napi::Value value) { exports.Set(name, value); });
 
     return exports;
 }

package/src/util.cc

@@ -215,8 +215,6 @@ void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
 
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
 
-    ptr = AlignUp(ptr, type->align);
-
     for (const RecordMember &member: type->members) {
         ptr = AlignUp(ptr, member.type->align);
 

package/src/util.hh

@@ -99,8 +99,8 @@ public:
         return MakeSpan(ptr, len);
     }
 
-    template <typename T>
-    bool AllocStack(Size size, Size align, T **out_ptr);
+    template <typename T = void>
+    bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
     template <typename T>
     bool AllocHeap(Size size, Size align, T **out_ptr);
 
@@ -127,7 +127,9 @@ bool CallData::AllocStack(Size size, Size align, T **out_ptr)
 
     stack_mem->len -= delta;
 
-    *out_ptr = (T *)ptr;
+    if (out_ptr) {
+        *out_ptr = (T *)ptr;
+    }
     return true;
 }
 

package/test/registry/machines.json

@@ -26,7 +26,8 @@
                 "directory": "/home/debian/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -64,7 +65,8 @@
                 "directory": "/home/debian/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -102,7 +104,8 @@
                 "directory": "/home/debian/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -140,7 +143,8 @@
                 "directory": "/home/debian/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -178,7 +182,8 @@
                 "directory": "C:/Users/windows/Desktop/luigi32",
                 "build": {
                     "Install": "C:\\Node32\\node32.cmd npm install --production --ignore-scripts",
-                    "Build": "C:\\Node32\\node32.cmd node ../cnoke/cnoke.js"
+                    "Build Koffi": "C:\\Node32\\node32.cmd node ../cnoke/cnoke.js",
+                    "Build dependencies": "C:\\Node32\\node32.cmd node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "seatsh C:\\Node32\\node32.cmd node test/tests/raylib.js",
@@ -191,7 +196,8 @@
                 "directory": "C:/Users/windows/Desktop/luigi64",
                 "build": {
                     "Install": "C:\\Node64\\node64.cmd npm install --production --ignore-scripts",
-                    "Build": "C:\\Node64\\node64.cmd node ../cnoke/cnoke.js"
+                    "Build Koffi": "C:\\Node64\\node64.cmd node ../cnoke/cnoke.js",
+                    "Build dependencies": "C:\\Node64\\node64.cmd node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "seatsh C:\\Node64\\node64.cmd node test/tests/raylib.js",
@@ -229,7 +235,8 @@
                 "directory": "/home/freebsd/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -267,7 +274,8 @@
                 "directory": "/home/freebsd/luigi",
                 "build": {
                     "Install": "npm install --production --ignore-scripts",
-                    "Build": "node ../cnoke/cnoke.js"
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -304,8 +312,9 @@
             "FreeBSD ARM64": {
                 "directory": "/home/freebsd/luigi",
                 "build": {
-                    "Build": "npm install --production --ignore-scripts",
-                    "Install": "node ../cnoke/cnoke.js"
+                    "Install": "npm install --production --ignore-scripts",
+                    "Build Koffi": "node ../cnoke/cnoke.js",
+                    "Build dependencies": "node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Raylib": "xvfb-run node test/tests/raylib.js",
@@ -343,7 +352,8 @@
                 "directory": "/Users/macos/luigi",
                 "build": {
                     "Install": "PATH=/usr/local/bin:/usr/bin:/bin npm install --production --ignore-scripts",
-                    "Build": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js"
+                    "Build Koffi": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js",
+                    "Build dependencies": "PATH=/usr/local/bin:/usr/bin:/bin SDKROOT=/Library/Developer/CommandLineTools/SDKs/MacOSX11.3.sdk node ../cnoke/cnoke.js -C test"
                 },
                 "commands": {
                     "Test Misc": "PATH=/usr/local/bin:/usr/bin:/bin node test/tests/misc.js",

package/test/test.js

@@ -23,13 +23,14 @@ const util = require('util');
 const { spawn, spawnSync } = require('child_process');
 const { NodeSSH } = require('node-ssh');
 const chalk = require('chalk');
+const minimatch = require('minimatch');
 
 // Globals
 
 let script_dir = null;
 let root_dir = null;
 
-let machines = [];
+let machines = null;
 let accelerate = true;
 let ignore = new Set;
 
@@ -47,6 +48,7 @@ async function main() {
     process.chdir(script_dir);
 
     let command = test;
+    let patterns = [];
 
     // Parse options
     {
@@ -54,19 +56,13 @@ async function main() {
 
         if (process.argv.length >= 3 && process.argv[2][0] != '-') {
             switch (process.argv[2]) {
-                case 'test': { command = test; } break;
-                case 'start': { command = start; } break;
-                case 'stop': { command = stop; } break;
-                case 'info': { command = info; } break;
-                case 'ssh': { command = ssh; } break;
-                case 'reset': { command = reset; } break;
-
-                default: {
-                    throw new Error(`Unknown command '${process.argv[2]}'`);
-                } break;
+                case 'test': { command = test; i++; } break;
+                case 'start': { command = start; i++; } break;
+                case 'stop': { command = stop; i++; } break;
+                case 'info': { command = info; i++; } break;
+                case 'ssh': { command = ssh; i++; } break;
+                case 'reset': { command = reset; i++; } break;
             }
-
-            i++;
         }
 
         for (; i < process.argv.length; i++) {
@@ -102,7 +98,7 @@ async function main() {
                 if (arg.startsWith('__') || arg.match(/[\\/\.]/))
                     throw new Error(`Machine name '${arg} is not valid`);
 
-                machines.push(arg);
+                patterns.push(arg);
             }
         }
     }
@@ -138,15 +134,34 @@ async function main() {
         }
     }
 
-    if (!machines.length) {
-        for (let name in machines_map)
-            machines.push(name);
+    if (patterns.length) {
+        machines = new Set;
+
+        for (let pattern of patterns) {
+            let re = minimatch.makeRe(pattern);
+
+            for (let name in machines_map) {
+                let machine = machines_map[name];
+
+                if (name.match(re) || machine.name.match(re))
+                    machines.add(name);
+            }
+        }
+
+        if (!machines.size) {
+            console.log('Could not match any machine');
+            process.exit(1);
+        }
+    } else {
+        machines = new Set(Object.keys(machines_map));
 
-        if (!machines.length) {
+        if (!machines.size) {
             console.error('Could not detect any machine');
             process.exit(1);
         }
     }
+
+    machines = Array.from(machines);
     machines = machines.map(name => {
         let machine = machines_map[name];
         if (machine == null) {
@@ -157,6 +172,9 @@ async function main() {
         return machine;
     });
 
+    console.log('Machines:', machines.map(machine => machine.name).join(', '));
+    console.log();
+
     try {
         let success = await command();
         process.exit(!success);
@@ -335,7 +353,7 @@ async function test() {
 
                     success = false;
 
-                    if (name == 'Build')
+                    if (name in test.build)
                         break;
                 }
             }
@@ -600,7 +618,7 @@ function log(machine, action, status) {
     }
 
     let align1 = Math.max(log.align - machine.name.length, 0);
-    let align2 = Math.max(30 - action.length, 0);
+    let align2 = Math.max(34 - action.length, 0);
 
     console.log(`     [${machine.name}]${' '.repeat(align1)}  ${action}${' '.repeat(align2)}  ${status}`);
 }

package/test/tests/misc.c

@@ -12,16 +12,24 @@
 // along with this program. If not, see https://www.gnu.org/licenses/.
 
 #include <stdio.h>
+#include <inttypes.h>
 
 #ifdef _WIN32
     #define EXPORT __declspec(dllexport)
 #else
     #define EXPORT __attribute__((visibility("default")))
 #endif
-#ifdef _MSC_VER
-    #define FASTCALL __fastcall
+#if defined(_M_IX86) || defined(__i386__)
+    #ifdef _MSC_VER
+        #define FASTCALL __fastcall
+        #define STDCALL __stdcall
+    #else
+        #define FASTCALL __attribute__((fastcall))
+        #define STDCALL __attribute__((stdcall))
+    #endif
 #else
-    #define FASTCALL __attribute__((fastcall))
+    #define FASTCALL
+    #define STDCALL
 #endif
 
 typedef struct Pack3 {
@@ -30,6 +38,22 @@ typedef struct Pack3 {
     int c;
 } Pack3;
 
+typedef struct IJK1 { int8_t i; int8_t j; int8_t k; } IJK1;
+typedef struct IJK4 { int32_t i; int32_t j; int32_t k; } IJK4;
+typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
+
+typedef struct BFG {
+    int8_t a;
+    int64_t b;
+    signed char c;
+    const char *d;
+    short e;
+    struct {
+        float f;
+        double g;
+    } inner;
+} BFG;
+
 EXPORT void FillPack3(int a, int b, int c, Pack3 *p)
 {
     p->a = a;
@@ -43,3 +67,74 @@ EXPORT void FASTCALL AddPack3(int a, int b, int c, Pack3 *p)
     p->b += b;
     p->c += c;
 }
+
+EXPORT int64_t ConcatenateToInt1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
+                                 int8_t g, int8_t h, int8_t i, int8_t j, int8_t k, int8_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT int64_t ConcatenateToInt4(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f,
+                                 int32_t g, int32_t h, int32_t i, int32_t j, int32_t k, int32_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT int64_t ConcatenateToInt8(int64_t a, int64_t b, int64_t c, int64_t d, int64_t e, int64_t f,
+                                 int64_t g, int64_t h, int64_t i, int64_t j, int64_t k, int64_t l)
+{
+    int64_t ret = 100000000000ull * a + 10000000000ull * b + 1000000000ull * c +
+                  100000000ull * d + 10000000ull * e + 1000000ull * f +
+                  100000ull * g + 10000ull * h + 1000ull * i +
+                  100ull * j + 10ull * k + 1ull * l;
+    return ret;
+}
+
+EXPORT const char *ConcatenateToStr1(int8_t a, int8_t b, int8_t c, int8_t d, int8_t e, int8_t f,
+                                     int8_t g, int8_t h, IJK1 ijk, int8_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%d%d%d%d", a, b, c, d, e, f, g, h, ijk.i, ijk.j, ijk.k, l);
+    return buf;
+}
+
+EXPORT const char *ConcatenateToStr4(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f,
+                                     int32_t g, int32_t h, IJK4 *ijk, int32_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%d%d%d%d", a, b, c, d, e, f, g, h, ijk->i, ijk->j, ijk->k, l);
+    return buf;
+}
+
+EXPORT const char *ConcatenateToStr8(int64_t a, int64_t b, int64_t c, int64_t d, int64_t e, int64_t f,
+                                     int64_t g, int64_t h, IJK8 ijk, int64_t l)
+{
+    static char buf[128];
+    snprintf(buf, sizeof(buf), "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64
+                               "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64 "%" PRIi64,
+             a, b, c, d, e, f, g, h, ijk.i, ijk.j, ijk.k, l);
+    return buf;
+}
+
+EXPORT BFG STDCALL MakeBFG(int x, double y)
+{
+    BFG bfg;
+
+    bfg.a = x;
+    bfg.b = x * 2;
+    bfg.c = x - 27;
+    bfg.d = "Hello";
+    bfg.e = x * 27;
+    bfg.inner.f = (float)y * x;
+    bfg.inner.g = (double)y - x;
+
+    return bfg;
+}