ffi 0.6.3 → 0.6.4

data/libtest/GlobalVariable.c

@@ -0,0 +1,56 @@
+#include <sys/types.h>
+#include <stdint.h>
+
+typedef int8_t s8;
+typedef uint8_t u8;
+typedef int16_t s16;
+typedef uint16_t u16;
+typedef int32_t s32;
+typedef uint32_t u32;
+typedef int64_t s64;
+typedef uint64_t u64;
+typedef signed long sL;
+typedef unsigned long uL;
+typedef float f32;
+typedef double f64;
+#if !defined(__OpenBSD__)
+typedef unsigned long ulong;
+#endif
+typedef void* pointer;
+typedef void* P;
+
+#define GVAR(T) \
+    extern T gvar_##T; \
+    T gvar_##T = (T) -1; \
+    T gvar_##T##_get() { return gvar_##T; }; \
+    void gvar_##T##_set(T v) { gvar_##T = v; }
+
+GVAR(s8);
+GVAR(u8);
+GVAR(s16);
+GVAR(u16);
+GVAR(s32);
+GVAR(u32);
+GVAR(s64);
+GVAR(u64);
+GVAR(long);
+GVAR(ulong);
+GVAR(pointer);
+
+struct gstruct {
+    long data;
+};
+
+struct gstruct gvar_gstruct = { -1 };
+
+struct gstruct*
+gvar_gstruct_get(void)
+{
+    return &gvar_gstruct;
+}
+
+void
+gvar_gstruct_set(const struct gstruct* val)
+{ 
+    gvar_gstruct = *val;
+}

data/libtest/LastErrorTest.c

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2008 Wayne Meissner. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#if defined(_WIN32) || defined(__WIN32__)
+# include <windows.h>
+#else
+# include <errno.h>
+#endif
+
+int setLastError(int error) {
+#if defined(_WIN32) || defined(__WIN32__)
+    SetLastError(error);
+#else
+    errno = error;
+#endif
+    return -1;
+}
+

data/libtest/NumberTest.c

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifdef __sparc
+    #define fix_mem_access __asm("ta 6")
+#else
+    #define fix_mem_access
+#endif
+
+typedef int8_t s8;
+typedef uint8_t u8;
+typedef int16_t s16;
+typedef uint16_t u16;
+typedef int32_t s32;
+typedef uint32_t u32;
+typedef int64_t s64;
+typedef uint64_t u64;
+typedef signed long sL;
+typedef unsigned long uL;
+typedef float f32;
+typedef double f64;
+#if !defined(__OpenBSD__)
+typedef unsigned long ulong;
+#endif
+
+#define ADD(T) T add_##T(T arg1, T arg2) { return arg1 + arg2; }
+#define SUB(T) T sub_##T(T arg1, T arg2) { return arg1 - arg2; }
+#define MUL(T) T mul_##T(T arg1, T arg2) { return arg1 * arg2; }
+#define DIV(T) T div_##T(T arg1, T arg2) { return arg1 / arg2; }
+#define RET(T) T ret_##T(T arg1) { return arg1; }
+#define SET(T) static T T##_;void set_##T(T arg1) { T##_ = arg1; }
+#define GET(T) T get_##T() { return T##_; }
+typedef char* ptr;
+#define TEST(T) ADD(T) SUB(T) MUL(T) DIV(T) RET(T) SET(T) GET(T)
+TEST(s8);
+TEST(u8);
+TEST(s16);
+TEST(u16);
+TEST(s32);
+TEST(u32);
+TEST(s64);
+TEST(u64);
+TEST(float);
+TEST(double);
+TEST(long);
+TEST(ulong);
+
+#define ADD2(R, T1, T2) R add_##T1##T2##_##R(T1 arg1, T2 arg2) { return arg1 + arg2; }
+#define SUB2(R, T1, T2) R sub_##T1##T2##_##R(T1 arg1, T2 arg2) { return arg1 - arg2; }
+#define MUL2(R, T1, T2) R mul_##T1##T2##_##R(T1 arg1, T2 arg2) { return arg1 * arg2; }
+#define DIV2(R, T1, T2) R div_##T1##T2##_##R(T1 arg1, T2 arg2) { return arg1 / arg2; }
+
+#define T2__(R, T1, T2) ADD2(R, T1, T2) SUB2(R, T1, T2) MUL2(R, T1, T2) DIV2(R, T1, T2)
+#define T2_(R, T1) \
+    T2__(R, T1, s8) T2__(R, T1, u8) \
+    T2__(R, T1, s16) T2__(R, T1, u16) \
+    T2__(R, T1, s32) T2__(R, T1, u32) \
+    T2__(R, T1, sL) T2__(R, T1, uL) \
+    T2__(R, T1, s64) T2__(R, T1, u64) \
+
+#define TEST2(R) \
+    T2_(R, s8) T2_(R, u8) T2_(R, s16) T2_(R, u16) T2_(R, s32) T2_(R, u32) \
+    T2_(R, sL) T2_(R, uL) T2_(R, s64) T2_(R, u64)
+
+#ifdef notyet
+TEST2(s32)
+TEST2(u32)
+TEST2(s64)
+TEST2(u64)
+#endif
+
+#define ADD3(R, T1, T2, T3) R add_##T1##T2##T3##_##R(T1 arg1, T2 arg2, T3 arg3) { return arg1 + arg2 + arg3; }
+#define pack_f32(buf, v) do { float f = v; memcpy((buf), &f, sizeof(f)); } while(0)
+#define pack_f64(buf, v) do { double f = v; memcpy((buf), &f, sizeof(f)); } while(0)
+#define pack_int(buf, v) do { *(buf) = v; } while(0)
+#define pack_s8 pack_int
+#define pack_u8 pack_int
+#define pack_s16 pack_int
+#define pack_u16 pack_int
+#define pack_s32 pack_int
+#define pack_u32 pack_int
+#define pack_s64 pack_int
+#define pack_u64 pack_int
+#define pack_sL pack_int
+#define pack_uL pack_int
+
+#define PACK3(R, T1, T2, T3) void pack_##T1##T2##T3##_##R(T1 arg1, T2 arg2, T3 arg3, R* r) { \
+    fix_mem_access; \
+    pack_##T1(&r[0], arg1); \
+    pack_##T2(&r[1], arg2); \
+    pack_##T3(&r[2], arg3); \
+}
+
+#define T3___(R, T1, T2, T3) PACK3(R, T1, T2, T3) /* SUB2(R, T1, T2) MUL2(R, T1, T2) DIV2(R, T1, T2) */
+#define T3__(R, T1, T2) \
+    T3___(R, T1, T2, s8) T3___(R, T1, T2, u8) \
+    T3___(R, T1, T2, s16) T3___(R, T1, T2, u16) \
+    T3___(R, T1, T2, s32) T3___(R, T1, T2, u32) \
+    T3___(R, T1, T2, sL) T3___(R, T1, T2, uL) \
+    T3___(R, T1, T2, s64) T3___(R, T1, T2, u64) \
+    T3___(R, T1, T2, f32) T3___(R, T1, T2, f64) \
+
+#define T3_(R, T1) \
+    T3__(R, T1, s8) T3__(R, T1, u8) \
+    T3__(R, T1, s16) T3__(R, T1, u16) \
+    T3__(R, T1, s32) T3__(R, T1, u32) \
+    T3__(R, T1, sL) T3__(R, T1, uL) \
+    T3__(R, T1, s64) T3__(R, T1, u64) \
+    T3__(R, T1, f32) T3__(R, T1, f64) \
+
+#define TEST3(R) \
+    T3_(R, s8) T3_(R, u8) T3_(R, s16) T3_(R, u16) T3_(R, s32) T3_(R, u32) \
+    T3_(R, sL) T3_(R, uL) T3_(R, s64) T3_(R, u64) T3_(R, f32) T3_(R, f64)
+
+TEST3(s64)
+

data/libtest/PointerTest.c

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+typedef void* ptr;
+typedef void* pointer;
+#ifdef _WIN32
+typedef char* caddr_t;
+#endif
+
+#define RET(T) T ptr_ret_##T(void* arg1, int offset) { \
+    T tmp; memcpy(&tmp, (caddr_t) arg1 + offset, sizeof(tmp)); return tmp; \
+}
+#define SET(T) void ptr_set_##T(void* arg1, int offset, T value) { \
+    memcpy((caddr_t) arg1 + offset, &value, sizeof(value)); \
+}
+#define TEST(T) SET(T) RET(T)
+
+TEST(int8_t);
+TEST(int16_t);
+TEST(int32_t);
+TEST(int64_t);
+TEST(float);
+TEST(double);
+TEST(pointer);
+
+void*
+ptr_return_array_element(void **ptrArray, int arrayIndex) 
+{
+    return ptrArray[arrayIndex];
+}
+
+void
+ptr_set_array_element(void **ptrArray, int arrayIndex, void *value)
+{    
+    ptrArray[arrayIndex] = value;
+}
+
+void*
+ptr_malloc(int size) 
+{
+    return calloc(1, size);
+}
+void
+ptr_free(void* ptr)
+{
+    free(ptr);
+}
+
+void*
+ptr_from_address(uintptr_t addr)
+{
+    return (void *) addr;
+}
+

data/libtest/ReferenceTest.c

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdint.h>
+
+#define REF(T) void ref_##T(T arg, T* result) { *result = arg; }
+#define ADD(T) void ref_add_##T(T arg1, T arg2, T* result) { *result = arg1 + arg2; }
+#define SUB(T) void ref_sub_##T(T arg1, T arg2, T* result) { *result = arg1 - arg2; }
+#define MUL(T) void ref_mul_##T(T arg1, T arg2, T* result) { *result = arg1 * arg2; }
+#define DIV(T) void ref_div_##T(T arg1, T arg2, T* result) { *result = arg1 / arg2; }
+#define TEST(T) ADD(T) SUB(T) MUL(T) DIV(T) REF(T)
+
+TEST(int8_t);
+TEST(int16_t);
+TEST(int32_t);
+TEST(int64_t);
+TEST(float);
+TEST(double);
+
+

data/libtest/StringTest.c

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <string.h>
+
+int 
+string_equals(const char* s1, const char* s2)
+{
+    return strcmp(s1, s2) == 0;
+}
+
+void 
+string_set(char* s1, const char* s2)
+{
+    strcpy(s1, s2);
+}
+void
+string_concat(char* dst, const char* src)
+{
+    strcat(dst, src);
+}
+void
+string_dummy(char* dummy)
+{
+}
+const char*
+string_null(void)
+{
+    return NULL;
+}
+

data/libtest/StructTest.c

@@ -0,0 +1,247 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * Neither the name of the project nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdarg.h>
+
+typedef char s8;
+typedef short s16;
+typedef int s32;
+typedef long long s64;
+typedef float f32;
+typedef double f64;
+
+typedef struct bugged_struct {
+  unsigned char visible;
+  unsigned int x;
+  unsigned int y;
+  short rx;
+  short ry;
+  unsigned char order;
+  unsigned char size;
+} bugged_struct_t;
+
+unsigned int
+bugged_struct_size() {
+    return sizeof(bugged_struct_t);
+}
+
+struct test1 {
+    char b;
+    short s;
+    int i;
+    long long j;
+    long l;
+    float f;
+    double d;
+    char string[32];
+};
+
+struct struct_with_array {
+    char c;
+    int a[5];
+};
+
+struct nested {
+    int i;
+};
+
+struct container {
+    char first;
+    struct nested s;
+};
+
+int
+struct_align_nested_struct(struct container* a) { return a->s.i; }
+
+void*
+struct_field_array(struct struct_with_array* s) { return &s->a; }
+
+struct container*
+struct_make_container_struct(int i)
+{
+    static struct container cs;
+    memset(&cs, 0, sizeof(cs));
+    cs.first = 1;
+    cs.s.i = i;
+    return &cs;
+}
+
+#define T(x, type) \
+    type struct_field_##type(struct test1* t) { return t->x; } \
+    struct type##_align { char first; type value; }; \
+    type struct_align_##type(struct type##_align* a) { return a->value; }
+
+T(b, s8);
+T(s, s16);
+T(i, s32);
+T(j, s64);
+T(f, f32);
+T(d, f64);
+T(l, long);
+
+void
+struct_set_string(struct test1* t, char* s)
+{
+    strcpy(t->string, s);
+}
+
+struct test1*
+struct_make_struct(char b, short s, int i, long long ll, float f, double d)
+{
+    static struct test1 t;
+    memset(&t, 0, sizeof(t));
+    t.b = b;
+    t.s = s;
+    t.i = i;
+    t.j = ll;
+    t.f = f;
+    t.d = d;
+    return &t;
+}
+
+typedef int (*add_cb)(int a1, int a2);
+typedef int (*sub_cb)(int a1, int a2);
+struct test2 {
+    add_cb  add_callback;
+    sub_cb  sub_callback;
+};
+
+int
+struct_call_add_cb(struct test2* t, int a1, int a2)
+{
+    return t->add_callback(a1, a2);
+}
+
+int
+struct_call_sub_cb(struct test2* t, int a1, int a2)
+{
+    return t->sub_callback(a1, a2);
+}
+
+
+struct struct_with_array*
+struct_make_struct_with_array(int a_0, int a_1, int a_2, int a_3, int a_4)
+{
+    static struct struct_with_array s;
+
+    memset(&s, 0, sizeof(s));
+
+    s.a[0] = a_0;
+    s.a[1] = a_1;
+    s.a[2] = a_2;
+    s.a[3] = a_3;
+    s.a[4] = a_4;
+
+    return &s;
+
+}
+
+struct s8s32 {
+    char s8;
+    int s32;
+};
+
+struct s8s32
+struct_return_s8s32()
+{
+    struct s8s32 s;
+    s.s8 = 0x7f;
+    s.s32 = 0x12345678;
+
+    return s;
+}
+
+struct s8s32
+struct_s8s32_set(char s8, int s32)
+{
+    struct s8s32 s;
+
+    s.s8 = s8;
+    s.s32 = s32;
+
+    return s;
+}
+
+int
+struct_s8s32_get_s8(struct s8s32 s)
+{
+    return s.s8;
+}
+
+int
+struct_s8s32_get_s32(struct s8s32 s)
+{
+    return s.s32;
+}
+
+// Pass a struct and an int arg, ensure the int arg is passed correctly
+int
+struct_s8s32_s32_ret_s32(struct s8s32 s, int s32)
+{
+    return s32;
+}
+
+// Pass a struct and a long long arg, ensure the long long arg is passed correctly
+long long
+struct_s8s32_s64_ret_s64(struct s8s32 s, long long s64)
+{
+    return s64;
+}
+
+// Pass a char *, copy into buffer length struct
+struct struct_string {
+    char *bytes;
+    int len;
+};
+
+struct struct_string
+struct_varargs_ret_struct_string(int len, ...)
+{
+    struct struct_string ss;
+    va_list vl;
+    char* cp = NULL;
+
+    va_start(vl, len);
+
+    ss.len = len;
+    ss.bytes = va_arg(vl, char *);
+    if (ss.bytes != NULL) {
+        cp = malloc(strlen(ss.bytes) + 1);
+        strcpy(cp, ss.bytes);
+        ss.bytes = cp;
+    }
+
+    va_end(vl);
+
+    return ss;
+}
+