koffi 1.3.5 → 1.3.8

package/src/abi_x64_sysv_fwd.S

@@ -66,7 +66,7 @@
 .endm
 
 # Prepare integer argument registers from array passed by caller.
-.macro forward_int
+.macro forward_gpr
     movq 40(%rsi), %r9
     movq 32(%rsi), %r8
     movq 24(%rsi), %rcx
@@ -89,66 +89,66 @@
 
 SYMBOL(ForwardCallGG):
     prologue
-    forward_int
+    forward_gpr
     movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallF):
     prologue
-    forward_int
+    forward_gpr
     movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallDG):
     prologue
-    forward_int
+    forward_gpr
     movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallGD):
     prologue
-    forward_int
+    forward_gpr
     movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallDD):
     prologue
-    forward_int
+    forward_gpr
     movb $0, %al
     epilogue
 
 SYMBOL(ForwardCallXGG):
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXF):
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXDG):
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXGD):
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     movb $8, %al
     epilogue
 
 SYMBOL(ForwardCallXDD):
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     movb $8, %al
     epilogue
 

package/src/abi_x64_win.cc

@@ -337,8 +337,15 @@ Napi::Value CallData::Complete()
 
 void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
-    const FunctionInfo *proto = instance->trampolines[idx].proto;
-    Napi::Function func = instance->trampolines[idx].func;
+    const TrampolineInfo &trampoline = instance->trampolines[idx];
+
+    if (RG_UNLIKELY(trampoline.generation != mem->generation)) {
+        ThrowError<Napi::Error>(env, "Cannot use non-persistent callback beyond FFI call");
+        return;
+    }
+
+    const FunctionInfo *proto = trampoline.proto;
+    Napi::Function func = trampoline.func.Value();
 
     uint64_t *gpr_ptr = (uint64_t *)own_sp;
     uint64_t *xmm_ptr = gpr_ptr + 4;

package/src/abi_x64_win_fwd.asm

@@ -53,7 +53,7 @@ epilogue macro
 endm
 
 ; Prepare integer argument registers from array passed by caller.
-forward_int macro
+forward_gpr macro
     mov r9, qword ptr [rdx+24]
     mov r8, qword ptr [rdx+16]
     mov rcx, qword ptr [rdx+0]
@@ -70,40 +70,40 @@ endm
 
 ForwardCallG proc frame
     prologue
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallG endp
 
 ForwardCallF proc frame
     prologue
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallF endp
 
 ForwardCallD proc frame
     prologue
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallD endp
 
 ForwardCallXG proc frame
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallXG endp
 
 ForwardCallXF proc frame
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallXF endp
 
 ForwardCallXD proc frame
     prologue
     forward_xmm
-    forward_int
+    forward_gpr
     epilogue
 ForwardCallXD endp
 

package/src/abi_x86.cc

@@ -411,8 +411,15 @@ Napi::Value CallData::Complete()
 
 void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
-    const FunctionInfo *proto = instance->trampolines[idx].proto;
-    Napi::Function func = instance->trampolines[idx].func;
+    const TrampolineInfo &trampoline = instance->trampolines[idx];
+
+    if (RG_UNLIKELY(trampoline.generation != mem->generation)) {
+        ThrowError<Napi::Error>(env, "Cannot use non-persistent callback beyond FFI call");
+        return;
+    }
+
+    const FunctionInfo *proto = trampoline.proto;
+    Napi::Function func = trampoline.func.Value();
 
     uint32_t *args_ptr = (uint32_t *)caller_sp;
 

package/src/abi_x86_fwd.S

@@ -124,6 +124,9 @@ ForwardCallRD:
 # static trampoline ID, the current stack pointer, a pointer to the stack arguments of this call,
 # and a pointer to a struct that will contain the result registers.
 # After the call, simply load these registers from the output struct.
+# Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
+# only takes an immediate value, and I prefer not to branch, the return address is moved instead according
+# to BackRegisters::ret_pop before ret is issued.
 .macro trampoline id
     .cfi_startproc
     .cfi_def_cfa esp, 4

package/src/abi_x86_fwd.asm

@@ -128,6 +128,9 @@ public CallSwitchStack
 ; static trampoline ID, the current stack pointer, a pointer to the stack arguments of this call,
 ; and a pointer to a struct that will contain the result registers.
 ; After the call, simply load these registers from the output struct.
+; Depending on ABI, call convention and return value size, we need to issue ret <something>. Since ret
+; only takes an immediate value, and I prefer not to branch, the return address is moved instead according
+; to BackRegisters::ret_pop before ret is issued.
 trampoline macro ID
     endbr32
     sub esp, 44

package/src/call.cc

@@ -24,6 +24,7 @@ CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *fu
     : env(env), instance(instance), func(func),
       mem(mem), old_stack_mem(mem->stack), old_heap_mem(mem->heap)
 {
+    mem->generation += !mem->depth;
     mem->depth++;
 
     RG_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
@@ -226,25 +227,33 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 *(uint64_t *)dest = v;
             } break;
             case PrimitiveKind::String: {
-                if (RG_UNLIKELY(!value.IsString())) {
+                const char *str;
+                if (RG_LIKELY(value.IsString())) {
+                    str = PushString(value);
+                    if (RG_UNLIKELY(!str))
+                        return false;
+                } else if (IsNullOrUndefined(value)) {
+                    str = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
                     return false;
                 }
 
-                const char *str = PushString(value);
-                if (RG_UNLIKELY(!str))
-                    return false;
                 *(const char **)dest = str;
             } break;
             case PrimitiveKind::String16: {
-                if (RG_UNLIKELY(!value.IsString())) {
+                const char16_t *str16;
+                if (RG_LIKELY(value.IsString())) {
+                    str16 = PushString16(value);
+                    if (RG_UNLIKELY(!str16))
+                        return false;
+                } else if (IsNullOrUndefined(value)) {
+                    str16 = nullptr;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
                     return false;
                 }
 
-                const char16_t *str16 = PushString16(value);
-                if (RG_UNLIKELY(!str16))
-                    return false;
                 *(const char16_t **)dest = str16;
             } break;
             case PrimitiveKind::Pointer: {
@@ -314,7 +323,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 if (value.IsFunction()) {
                     Napi::Function func = value.As<Napi::Function>();
 
-                    ptr = ReserveTrampoline(type->proto, func);
+                    ptr = ReserveTrampoline(member.type->proto, func);
                     if (RG_UNLIKELY(!ptr))
                         return false;
                 } else if (CheckValueTag(instance, value, member.type)) {
@@ -748,7 +757,8 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
     used_trampolines |= 1u << idx;
 
     instance->trampolines[idx].proto = proto;
-    instance->trampolines[idx].func = func;
+    instance->trampolines[idx].func.Reset(func, 1);
+    instance->trampolines[idx].generation = mem->generation;
 
     void *trampoline = GetTrampoline(idx, proto);
     return trampoline;

package/src/ffi.cc

@@ -550,7 +550,7 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
         if (!ParsePrototype(env, proto.c_str(), func))
             return env.Null();
     } else {
-        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, got %1", info.Length());
         return env.Null();
     }
 
@@ -894,7 +894,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         if (!ParsePrototype(env, proto.c_str(), func))
             return env.Null();
     } else {
-        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, got %1", info.Length());
         return env.Null();
     }
 
@@ -957,7 +957,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, not %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
         return env.Null();
     }
     if (!info[0].IsString() && !IsNullOrUndefined(info[0])) {
@@ -1075,9 +1075,12 @@ static void RegisterPrimitiveType(InstanceData *instance, const char *name, Prim
     instance->types_map.Set(type);
 }
 
-static inline PrimitiveKind GetLongPrimitive(bool sign)
+template <typename T>
+static inline PrimitiveKind GetIntegerPrimitive(bool sign)
 {
-    switch (RG_SIZE(long)) {
+    switch (RG_SIZE(T)) {
+        case 1: return sign ? PrimitiveKind::Int8 : PrimitiveKind::UInt8;
+        case 2: return sign ? PrimitiveKind::Int16 : PrimitiveKind::UInt16;
         case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
         case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
     }
@@ -1121,9 +1124,13 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     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", GetLongPrimitive(true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "ulong", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "unsigned long", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "intptr", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "intptr_t", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "uintptr", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "uintptr_t", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "long", GetIntegerPrimitive<long>(true), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "ulong", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "unsigned long", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
     RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
     RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
     RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
@@ -1134,6 +1141,8 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
     RegisterPrimitiveType(instance, "string16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "str16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {

package/src/ffi.hh

@@ -86,7 +86,6 @@ struct TypeInfo {
     };
 
     const char *name;
-    napi_type_tag tag;
 
     Napi::ObjectReference defn;
 
@@ -199,13 +198,15 @@ struct InstanceMemory {
     Span<uint8_t> stack;
     Span<uint8_t> heap;
 
-    int depth;
+    uint16_t generation; // Can wrap without risk
+    int16_t depth;
     bool temporary;
 };
 
 struct TrampolineInfo {
     const FunctionInfo *proto;
-    Napi::Function func;
+    Napi::FunctionReference func;
+    uint16_t generation;
 };
 
 struct InstanceData {

package/src/util.cc

@@ -28,7 +28,7 @@ const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int
         const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
 
         if (!type) {
-            ThrowError<Napi::TypeError>(value.Env(), "Unknown type string '%1'", str.c_str());
+            ThrowError<Napi::TypeError>(value.Env(), "Unknown type name '%1'", str.c_str());
             return nullptr;
         }
 

package/test/async.js

@@ -21,7 +21,7 @@ const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.pack({
         f: 'float',

package/test/callbacks.js

@@ -21,7 +21,7 @@ const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -30,9 +30,16 @@ const BFG = koffi.struct('BFG', {
 });
 
 const SimpleCallback = koffi.callback('int SimpleCallback(const char *str)');
-const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'string', 'double']);
+const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'str', 'double']);
 const BigCallback = koffi.callback('BFG BigCallback(BFG bfg)');
 const ApplyCallback = koffi.callback('int __stdcall ApplyCallback(int a, int b, int c)');
+const IntCallback = koffi.callback('int IntCallback(int x)');
+
+const StructCallbacks = koffi.struct('StructCallbacks', {
+    first: IntCallback,
+    second: IntCallback,
+    third: IntCallback
+});
 
 main();
 
@@ -54,6 +61,8 @@ async function test() {
     const CallRecursiveJS = lib.func('float CallRecursiveJS(int i, RecursiveCallback func)');
     const ModifyBFG = lib.func('BFG ModifyBFG(int x, double y, const char *str, BigCallback func, _Out_ BFG *p)');
     const ApplyStd = lib.func('int ApplyStd(int a, int b, int c, ApplyCallback func)');
+    const ApplyMany = lib.func('int ApplyMany(int x, IntCallback *funcs, int length)');
+    const ApplyStruct = lib.func('int ApplyStruct(int x, StructCallbacks callbacks)');
 
     // Simple test similar to README example
     {
@@ -92,4 +101,18 @@ async function test() {
         let ret = ApplyStd(1, 5, 9, (a, b, c) => a + b * c);
         assert.equal(ret, 46);
     }
+
+    // Array of callbacks
+    {
+        let callbacks = [x => x * 5, x => x - 42, x => -x];
+        let ret = ApplyMany(27, callbacks, callbacks.length);
+        assert.equal(ret, -93);
+    }
+
+    // Struct of callbacks
+    {
+        let callbacks = { first: x => -x, second: x => x * 5, third: x => x - 42 };
+        let ret = ApplyStruct(27, callbacks);
+        assert.equal(ret, -177);
+    }
 }

package/test/misc.c

@@ -129,6 +129,20 @@ typedef struct IntContainer {
     int len;
 } IntContainer;
 
+typedef struct StrStruct {
+    const char *str;
+    const char16_t *str16;
+} StrStruct;
+
+typedef int STDCALL ApplyCallback(int a, int b, int c);
+typedef int IntCallback(int x);
+
+typedef struct StructCallbacks {
+    IntCallback *first;
+    IntCallback *second;
+    IntCallback *third;
+} StructCallbacks;
+
 EXPORT int8_t GetMinusOne1(void)
 {
     return -1;
@@ -385,7 +399,12 @@ EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const cha
     return bfg;
 }
 
+#ifdef _WIN32
+// Exported by DEF file
+const char *ReturnBigString(const char *str)
+#else
 EXPORT const char *ReturnBigString(const char *str)
+#endif
 {
     static char buf[16 * 1024 * 1024];
 
@@ -530,8 +549,6 @@ EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG
     return bfg;
 }
 
-typedef int STDCALL ApplyCallback(int a, int b, int c);
-
 EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
 {
     int ret = func(a, b, c);
@@ -563,3 +580,41 @@ EXPORT void MultiplyIntegers(int multiplier, int *values, int len)
         values[i] *= multiplier;
     }
 }
+
+EXPORT const char *ThroughStr(StrStruct s)
+{
+    return s.str;
+}
+
+EXPORT const char16_t *ThroughStr16(StrStruct s)
+{
+    return s.str16;
+}
+
+EXPORT const char *ThroughStrStar(StrStruct *s)
+{
+    return s->str;
+}
+
+EXPORT const char16_t *ThroughStrStar16(StrStruct *s)
+{
+    return s->str16;
+}
+
+EXPORT int ApplyMany(int x, IntCallback **callbacks, int length)
+{
+    for (int i = 0; i < length; i++) {
+        x = (callbacks[i])(x);
+    }
+
+    return x;
+}
+
+EXPORT int ApplyStruct(int x, StructCallbacks callbacks)
+{
+    x = callbacks.first(x);
+    x = callbacks.second(x);
+    x = callbacks.third(x);
+
+    return x;
+}

package/test/raylib.js

@@ -86,14 +86,14 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/build/raylib' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
-    const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'string']);
+    const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'str']);
     const SetTraceLogLevel = lib.func('SetTraceLogLevel', 'void', ['int']);
     const SetWindowState = lib.func('SetWindowState', 'void', ['uint']);
     const GenImageColor = lib.func('GenImageColor', Image, ['int', 'int', Color]);
     const GetFontDefault = lib.func('GetFontDefault', Font, []);
-    const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
-    const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'string', Vector2, 'float', 'float', Color]);
-    const ExportImage = lib.func('ExportImage', 'bool', [Image, 'string']);
+    const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'str', 'float', 'float']);
+    const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'str', Vector2, 'float', 'float', Color]);
+    const ExportImage = lib.func('ExportImage', 'bool', [Image, 'str']);
 
     // We need to call InitWindow before using anything else (such as fonts)
     SetTraceLogLevel(4); // Warnings

package/test/sqlite.js

@@ -39,13 +39,13 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/build/sqlite3' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
-    const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['string', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'string']);
-    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'string', 'void *', 'void *', 'void *']);
-    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'string', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
+    const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'str']);
+    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'str', 'void *', 'void *', 'void *']);
+    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'str', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
     const sqlite3_reset = lib.func('sqlite3_reset', 'int', [sqlite3_stmt]);
-    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'string', 'int', 'void *']);
+    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'str', 'int', 'void *']);
     const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [sqlite3_stmt, 'int', 'int']);
-    const sqlite3_column_text = lib.func('sqlite3_column_text', 'string', [sqlite3_stmt, 'int']);
+    const sqlite3_column_text = lib.func('sqlite3_column_text', 'str', [sqlite3_stmt, 'int']);
     const sqlite3_column_int = lib.func('sqlite3_column_int', 'int', [sqlite3_stmt, 'int']);
     const sqlite3_step = lib.func('sqlite3_step', 'int', [sqlite3_stmt]);
     const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [sqlite3_stmt]);

package/test/sync.js

@@ -64,7 +64,7 @@ const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -75,7 +75,7 @@ const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.pack({
         f: 'float',
@@ -106,6 +106,11 @@ const IntContainer = koffi.struct('IntContainer', {
     len: 'int'
 });
 
+const StrStruct = koffi.struct('StrStruct', {
+    str: 'str',
+    str16: 'str16'
+});
+
 main();
 
 async function main() {
@@ -146,13 +151,13 @@ async function test() {
     const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
     const ConcatenateToInt4 = lib.func('ConcatenateToInt4', 'int64_t', Array(12).fill('int32_t'));
     const ConcatenateToInt8 = lib.func('ConcatenateToInt8', 'int64_t', Array(12).fill('int64_t'));
-    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
-    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
-    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
+    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'str', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
+    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'str', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
+    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'str', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
     const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
     const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
     const ReturnBigString = process.platform == 'win32' ?
-                            lib.stdcall(1, 'string', ['string']) :
+                            lib.stdcall(1, 'str', ['str']) :
                             lib.func('const char * __stdcall ReturnBigString(const char *str)');
     const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
     const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
@@ -175,6 +180,8 @@ async function test() {
     const ArrayToStruct = lib.func('IntContainer ArrayToStruct(int *ptr, int len)');
     const FillRange = lib.func('void FillRange(int init, int step, _Out_ int *out, int len)');
     const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
+    const ThroughStr = lib.func('str ThroughStr(StrStruct s)');
+    const ThroughStr16 = lib.func('str16 ThroughStr16(StrStruct s)');
 
     // Simple signed value returns
     assert.equal(GetMinusOne1(), -1);
@@ -292,7 +299,7 @@ async function test() {
 
     // Variadic
     {
-        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
+        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'str', 'BAR');
         assert.equal(str, 'foo 200 1.5 BAR');
     }
 
@@ -367,4 +374,12 @@ async function test() {
         assert.deepEqual(out1, [-2, -9, -16, -23, -30, -37, -44, -51, 58, 65]);
         assert.deepEqual(out2, new Int32Array([3 * 13, 3 * 16, 3 * 19, 3 * 22, 3 * 25, 3 * 28, 3 * 31, 34, 37, 40]));
     }
+
+    // Test struct strings
+    {
+        assert.equal(ThroughStr({ str: 'Hello', str16: null }), 'Hello');
+        assert.equal(ThroughStr({ str: null, str16: 'Hello' }), null);
+        assert.equal(ThroughStr16({ str: null, str16: 'World!' }), 'World!');
+        assert.equal(ThroughStr16({ str: 'World!', str16: null }), null);
+    }
 }