alinta-ffi 1.9.19

data/libtest/StringTest.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#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,243 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner.
+ * Copyright (c) 2009 Andrea Fazzi <andrea.fazzi@alcacoop.it>.
+ *
+ * All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#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;
+}
+
+struct s8s32
+struct_s8s32_ret_s8s32(struct s8s32 s)
+{
+    return s;
+}
+
+// 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 struct and a long long arg, ensure the long long arg is passed correctly
+int
+struct_s32_ptr_s32_s8s32_ret_s32(int s32a, void *ptr, int s32b, struct s8s32 s)
+{
+    if (ptr != NULL) *(struct s8s32 *) ptr = s;
+    return s.s32;
+}
+
+// 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;
+}
+

data/libtest/UnionTest.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+typedef char s8;
+typedef short s16;
+typedef int s32;
+typedef long long s64;
+typedef float f32;
+typedef double f64;
+
+typedef union union_test {
+    char b;
+    short s;
+    int i;
+    long long j;
+    long l;
+    float f;
+    double d;
+    s8 a[10];
+} union_test_t;
+
+#define T(x, type) \
+  type union_align_##type(union_test_t* u) { return u->x; } \
+  union_test_t* union_make_union_with_##type(type value) { static union_test_t u; u.x = value; return &u; }
+
+T(b, s8);
+T(s, s16);
+T(i, s32);
+T(j, s64);
+T(f, f32);
+T(d, f64);
+T(l, long);
+
+unsigned int union_size() { return sizeof(union_test_t); }

data/libtest/VariadicTest.c

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdarg.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 F;
+typedef double D;
+
+void pack_varargs(s64* buf, const char* fmt, ...)
+{
+    va_list ap;
+    int c;
+    double d;
+    va_start(ap, fmt);
+    while ((c = *fmt++)) {
+        switch (c) {
+            case 'c':
+            case 's':
+            case 'i':
+                *buf++ = va_arg(ap, s32);
+                break;
+            case 'l':
+                *buf++ = va_arg(ap, long);
+                break;
+            case 'j':
+                *buf++ = va_arg(ap, s64);
+                break;
+            case 'f':
+            case 'd':
+                d = va_arg(ap, double);
+                memcpy(buf++, &d, sizeof(d));
+                break;
+            case 'C':
+            case 'S':
+            case 'I':
+                *buf++ = va_arg(ap, u32);
+                break;
+            case 'L':
+                *buf++ = va_arg(ap, unsigned long);
+                break;
+        }
+    }
+    va_end(ap);
+}
+
+int pack_varargs2(s64* buf, int retval, const char* fmt, ...)
+{
+    va_list ap;
+    int c;
+    double d;
+    va_start(ap, fmt);
+    while ((c = *fmt++)) {
+        switch (c) {
+            case 'c':
+            case 's':
+            case 'i':
+                *buf++ = va_arg(ap, s32);
+                break;
+            case 'l':
+                *buf++ = va_arg(ap, long);
+                break;
+            case 'j':
+                *buf++ = va_arg(ap, s64);
+                break;
+            case 'f':
+            case 'd':
+                d = va_arg(ap, double);
+                memcpy(buf++, &d, sizeof(d));
+                break;
+            case 'C':
+            case 'S':
+            case 'I':
+                *buf++ = va_arg(ap, u32);
+                break;
+            case 'L':
+                *buf++ = va_arg(ap, unsigned long);
+                break;
+        }
+    }
+    va_end(ap);
+    return retval + 1;
+}

data/spec/ffi/LICENSE.SPECS

@@ -0,0 +1,22 @@
+Copyright (c) 2008-2014 Ruby-FFI contributors
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/spec/ffi/async_callback_spec.rb

@@ -0,0 +1,35 @@
+#
+# This file is part of ruby-ffi.
+# For licensing, see LICENSE.SPECS
+#
+
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+
+describe "async callback" do
+  module LibTest
+    extend FFI::Library
+    ffi_lib TestLibrary::PATH
+    AsyncIntCallback = callback [ :int ], :void
+
+    @blocking = true
+    attach_function :testAsyncCallback, [ AsyncIntCallback, :int ], :void
+  end
+
+  it ":int (0x7fffffff) argument" do
+    v = 0xdeadbeef
+    called = false
+    cb = Proc.new {|i| v = i; called = true }
+    LibTest.testAsyncCallback(cb, 0x7fffffff) 
+    expect(called).to be true
+    expect(v).to eq(0x7fffffff)
+  end
+  
+  it "called a second time" do
+    v = 0xdeadbeef
+    called = false
+    cb = Proc.new {|i| v = i; called = true }
+    LibTest.testAsyncCallback(cb, 0x7fffffff) 
+    expect(called).to be true
+    expect(v).to eq(0x7fffffff)
+  end
+end