scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/Benchmark.c

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+#include <sys/types.h>
+#include <stdint.h>
+
+void returnVoid() {
+    
+}
+
+void returnVoidI(int arg) {
+    
+}
+int returnInt() {
+    return 0;
+}
+
+int returnIntI(int arg) {
+    return arg;
+}
+
+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 float f32;
+typedef double f64;
+typedef void v;
+typedef char* S;
+typedef void* P;
+
+#define B6(R, T1, T2, T3, T4, T5, T6) R bench_##T1##T2##T3##T4##T5##T6##_##R(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6) {}
+#define B5(R, T1, T2, T3, T4, T5) R bench_##T1##T2##T3##T4##T5##_##R(T1 a1, T2 a2, T3 a3, T4 a4, T5 a5) {}
+#define B4(R, T1, T2, T3, T4) R bench_##T1##T2##T3##T4##_##R(T1 a1, T2 a2, T3 a3, T4 a4) {}
+#define B3(R, T1, T2, T3) R bench_##T1##T2##T3##_##R(T1 a1, T2 a2, T3 a3) {}
+#define B2(R, T1, T2) R bench_##T1##T2##_##R(T1 a1, T2 a2) {}
+#define B1(R, T1) R bench_##T1##_##R(T1 a1) {}
+#define BrV(T) B1(v, T); B2(v, T, T); B3(v, T, T, T); B4(v, T, T, T, T); B5(v, T, T, T, T, T); B6(v, T, T, T, T, T, T);
+BrV(u32);
+BrV(s32);
+BrV(s64);
+BrV(u64);
+BrV(f32);
+BrV(f64);
+BrV(S);
+BrV(P);

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/BoolTest.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner.
+ * Copyright (c) 2009 Aman Gupta.
+ *
+ * All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdbool.h>
+
+bool
+bool_return_true()
+{
+    return true;
+}
+
+bool
+bool_return_false()
+{
+    return false;
+}
+
+bool
+bool_return_val(bool value)
+{
+    return value;
+}
+
+bool
+bool_reverse_val(bool value)
+{
+    return value ? false : true;
+}

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/BufferTest.c

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+
+#define MEMSET(buf, value, size) do { \
+    int i; for (i = 0; i < size; ++i) buf[i] = value; \
+} while(0)
+#define MEMCPY(dst, src, size) do { \
+    int i; for (i = 0; i < size; ++i) dst[i] = src[i]; \
+} while(0)
+
+#define FILL(JTYPE, CTYPE) \
+void fill##JTYPE##Buffer(CTYPE* buf, CTYPE value, int size) { MEMSET(buf, value, size); }
+
+#define COPY(JTYPE, CTYPE) \
+void copy##JTYPE##Buffer(CTYPE* dst, CTYPE* src, int size) { MEMCPY(dst, src, size); }
+
+#define FUNC(JTYPE, CTYPE) \
+    FILL(JTYPE, CTYPE); \
+    COPY(JTYPE, CTYPE)
+            
+FUNC(Byte, char);
+FUNC(Short, short);
+FUNC(Int, int);
+FUNC(Long, long long);
+FUNC(Float, float);
+FUNC(Double, double);
+

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/ClosureTest.c

@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#include <stdlib.h>
+#include <stdbool.h>
+#ifndef _WIN32
+# include <pthread.h>
+#else
+# include <windows.h>
+# include <process.h>
+#endif
+
+#define R(T, rtype) rtype testClosureVr##T(rtype (*closure)(void)) { \
+    return closure != NULL ? (*closure)() : (rtype) 0; \
+}
+
+#define P(T, ptype) void testClosure##T##rV(void (*closure)(ptype), ptype a1) { \
+    if (closure != NULL) (*closure)(a1); \
+}
+
+void testClosureVrV(void (*closure)(void))
+{
+    (*closure)();
+}
+
+R(Z, bool);
+R(B, char);
+R(S, short);
+R(I, int);
+R(L, long);
+R(J, long long);
+R(LL, long long);
+R(F, float);
+R(D, double);
+R(P, const void*);
+
+
+P(Z, bool);
+P(B, char);
+P(S, short);
+P(I, int);
+P(L, long);
+P(J, long long);
+P(LL, long long);
+P(F, float);
+P(D, double);
+P(P, const void*);
+P(UL, unsigned long);
+
+#if defined(_WIN32) && !defined(_WIN64)
+bool __stdcall testClosureStdcall(long *a1, void __stdcall(*closure)(void *, long), long a2) { \
+    void* sp_pre;
+    void* sp_post;
+
+    asm volatile (" movl %%esp,%0" : "=g" (sp_pre));
+    (*closure)(a1, a2);
+    asm volatile (" movl %%esp,%0" : "=g" (sp_post));
+
+    /* %esp before pushing parameters on the stack and after the call returns
+     * should be equal, if both sides respects the stdcall convention */
+    return sp_pre == sp_post;
+}
+#endif
+
+void testOptionalClosureBrV(void (*closure)(char), char a1)
+{
+    if (closure) {
+        (*closure)(a1);
+    }
+}
+
+
+struct ThreadVrV {
+    void (*closure)(void);
+    int count;
+};
+
+static void *
+threadVrV(void *arg)
+{
+    struct ThreadVrV* t = (struct ThreadVrV *) arg;
+    
+    int i;
+    for (i = 0; i < t->count; i++) {
+        (*t->closure)();
+    }
+    
+    return NULL;
+}
+
+void testThreadedClosureVrV(void (*closure)(void), int n)
+{
+	struct ThreadVrV arg = {closure, n};
+#ifndef _WIN32
+    pthread_t t;
+    pthread_create(&t, NULL, threadVrV, &arg);
+    pthread_join(t, NULL);
+#else
+    HANDLE hThread = (HANDLE) _beginthread((void (*)(void *))threadVrV, 0, &arg);
+    WaitForSingleObject(hThread, INFINITE);	
+#endif
+}
+
+struct s8f32s32 {
+    char s8;
+    float f32;
+    int s32;
+};
+
+// Takes a struct argument
+void testClosureTrV(void (*closure)(struct s8f32s32 s), struct s8f32s32* s)
+{
+    (*closure)(*s);
+}
+
+// Returns a struct value
+struct s8f32s32 testClosureVrT(struct s8f32s32 (*closure)())
+{
+    return (*closure)();
+}
+
+typedef int (*returnTypeClosure_t)(int) ;
+typedef returnTypeClosure_t (*lookupClosure_t)();
+
+int testReturnsClosure(lookupClosure_t lookup, int val)
+{
+    returnTypeClosure_t func = lookup ? (*lookup)() : NULL;
+    return func ? (*func)(val) : 0;
+}
+
+static int multiplyByTwo(int value)
+{
+    return value * 2;
+}
+
+returnTypeClosure_t testReturnsFunctionPointer()
+{
+    return multiplyByTwo;
+}
+
+typedef int (*argumentClosure_t)(int);
+typedef int (*withArgumentClosure_t)(argumentClosure_t, int);
+
+int testArgumentClosure(withArgumentClosure_t closure_with, argumentClosure_t closure_arg, int val)
+{
+    return (*closure_with)(closure_arg, val);
+}
+
+
+//
+// These macros produce functions of the form:
+// testClosureBIrV(void (*closure)(char, int), char a1, int a2) {}
+//
+#define C2_(J1, J2, N1, N2) \
+void testClosure##J1##J2##rV(void (*closure)(N1, N2), N1 a1, N2 a2) \
+{ \
+    if (closure != NULL) (*closure)(a1, a2); \
+}
+
+#define C2(J, N) \
+    C2_(B, J, char, N) \
+    C2_(S, J, short, N) \
+    C2_(I, J, int, N) \
+    C2_(LL, J, long long, N) \
+    C2_(F, J, float, N) \
+    C2_(D, J, double, N) \
+
+
+C2(B, char);
+C2(S, short);
+C2(I, int);
+C2(LL, long long);
+C2(F, float);
+C2(D, double);
+
+#define C3_(J1, J2, J3, N1, N2, N3) \
+void testClosure##J1##J2##J3##rV(void (*closure)(N1, N2, N3), N1 a1, N2 a2, N3 a3) \
+{ \
+    (*closure)(a1, a2, a3); \
+}
+
+
+#define C3(J, N) \
+    C3_(B, J, B, char, N, char) \
+    C3_(S, J, S, short, N, short) \
+    C3_(I, J, I, int, N, int) \
+    C3_(LL, J, LL, long long, N, long long) \
+    C3_(F, J, F, float, N, float) \
+    C3_(D, J, D, double, N, double) \
+
+C3(B, char);
+C3(S, short);
+C3(I, int);
+C3(LL, long long);
+C3(F, float);
+C3(D, double);
+C3_(B, S, I, char, short, int);
+C3_(B, S, LL, char, short, long long);
+C3_(LL, S, B, long long, short, char);
+C3_(LL, B, S, long long, char, short);
+
+

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/EnumTest.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+#include <stdint.h>
+
+int test_untagged_enum(int val) {
+    return val;
+}
+
+int test_untagged_typedef_enum(int val) {
+    return val;
+}
+
+uint8_t test_untagged_nonint_enum(uint8_t val) {
+    return val;
+}
+
+uint16_t test_tagged_nonint_enum1(uint16_t val) {
+    return val;
+}
+
+uint32_t test_tagged_nonint_enum2(uint32_t val) {
+    return val;
+}
+
+uint64_t test_tagged_nonint_enum3(uint64_t val) {
+    return val;
+}
+
+typedef enum {c1, c2, c3, c4} enum_type1;
+enum_type1 test_tagged_typedef_enum1(enum_type1 val) {
+    return val;
+}
+
+typedef enum {c5 = 42, c6, c7, c8} enum_type2;
+enum_type2 test_tagged_typedef_enum2(enum_type2 val) {
+    return val;
+}
+
+typedef enum {c9 = 42, c10, c11 = 4242, c12} enum_type3;
+enum_type3 test_tagged_typedef_enum3(enum_type3 val) {
+    return val;
+}
+
+typedef enum {c13 = 42, c14 = 4242, c15 = 424242, c16 = 42424242} enum_type4;
+enum_type4 test_tagged_typedef_enum4(enum_type4 val) {
+    return val;
+}
+

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/FunctionTest.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#ifdef _WIN32
+#include <windows.h>
+#define sleep(x) Sleep(x)
+#endif
+
+#ifndef _WIN32
+#include <unistd.h>
+#include <pthread.h>
+#endif
+
+int testAdd(int a, int b)
+{
+    return a + b;
+};
+
+int testFunctionAdd(int a, int b, int (*f)(int, int))
+{
+    return f(a, b);
+};
+
+void testBlocking(int seconds) {
+    sleep(seconds);
+};
+
+struct async_data {
+    void (*fn)(int);
+    int value;
+};
+
+static void* asyncThreadCall(void *data)
+{
+    struct async_data* d = (struct async_data *) data;
+    if (d != NULL && d->fn != NULL) {
+        (*d->fn)(d->value);
+    }
+
+    return NULL;
+}
+
+void testAsyncCallback(void (*fn)(int), int value)
+{
+#ifndef _WIN32
+    pthread_t t;
+    struct async_data d;
+    d.fn = fn;
+    d.value = value;
+    pthread_create(&t, NULL, asyncThreadCall, &d);
+    pthread_join(t, NULL);
+#else
+    (*fn)(value);
+#endif
+} 
+
+#if defined(_WIN32) && !defined(_WIN64)
+struct StructUCDP {
+  unsigned char a1;
+  double a2;
+  void *a3;
+};
+
+void __stdcall testStdcallManyParams(long *a1, char a2, short int a3, int a4, __int64 a5,
+            struct StructUCDP a6, struct StructUCDP *a7, float a8, double a9) {
+}
+#endif

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/GNUmakefile

@@ -0,0 +1,149 @@
+# -*- makefile -*-
+
+ifeq ($(OS),)
+  BUILD_OS := $(shell uname -s | tr '[:upper:]' '[:lower:]')
+  OS := $(BUILD_OS)
+endif
+
+ifeq ($(CPU),)
+  CPU := $(shell uname -m | sed -e 's/i[345678]86/i386/')
+endif
+
+PLATFORM = $(CPU)-$(OS)
+
+ifeq ($(OS), sunos)
+  OS = solaris
+endif
+
+SRC_DIR = libtest
+BUILD_DIR ?= build
+TEST_BUILD_DIR = $(BUILD_DIR)/libtest
+# Set defaults to unix (linux/solaris/bsd)
+PREFIX = lib
+LIBEXT ?= so
+LIBNAME = $(PREFIX)test.$(LIBEXT)
+
+export MACOSX_DEPLOYMENT_TARGET=10.4
+
+CCACHE := $(strip $(realpath $(shell which ccache 2> /dev/null)))
+
+TEST_SRCS = $(wildcard $(SRC_DIR)/*.c)
+TEST_OBJS := $(patsubst $(SRC_DIR)/%.c, $(TEST_BUILD_DIR)/%.o, $(TEST_SRCS))
+
+#
+# Compiler/linker flags from:
+#   http://weblogs.java.net/blog/kellyohair/archive/2006/01/compilation_of_1.html
+JFLAGS = -fno-omit-frame-pointer -fno-strict-aliasing
+OFLAGS = -O2 $(JFLAGS)
+WFLAGS = -W -Wall -Wno-unused -Wno-parentheses
+PICFLAGS = -fPIC
+SOFLAGS = -shared
+LDFLAGS += $(SOFLAGS)
+
+IFLAGS = -I"$(BUILD_DIR)"
+CFLAGS = $(OFLAGS) $(WFLAGS) $(IFLAGS) $(PICFLAGS) -D_REENTRANT
+
+ifneq ($(strip $(findstring $(OS), win32, mingw, cygwin)),)
+  # For cygwin => win32-native builds, strip out cygwin deps
+  ifneq ($(findstring cygwin, $(BUILD_OS)),)
+    CC += -mno-cygwin -mwin32
+    LDFLAGS += -mno-cygwin -Wl,--add-stdcall-alias
+  endif
+  PICFLAGS=
+  LIBEXT=dll
+  CC = gcc
+endif
+
+ifeq ($(OS), darwin)
+  ifneq ($(findstring $(CPU),ppc),)
+    ARCHFLAGS += -arch ppc
+  endif
+  ifneq ($(findstring $(CPU),i386 x86_64),)
+    ARCHFLAGS += -arch i386 -arch x86_64
+  endif
+  CFLAGS += $(ARCHFLAGS) -DTARGET_RT_MAC_CFM=0
+  CFLAGS += -fno-common
+  LDFLAGS = $(ARCHFLAGS) -dynamiclib
+  # link against the universal libraries on ppc machines
+  LDFLAGS += -L$(MACSDK)/usr/lib
+  LIBEXT = dylib
+  FFI_CFLAGS += -isysroot $(MACSDK)
+  PICFLAGS =
+  SOFLAGS =
+endif
+
+ifeq ($(OS), linux)
+  SOFLAGS += -Wl,-soname,$(LIBNAME)
+endif
+
+ifeq ($(OS), solaris)
+  CC = /usr/sfw/bin/gcc -std=c99
+  LD = /usr/ccs/bin/ld
+  SOFLAGS = -shared -static-libgcc 
+endif
+
+ifeq ($(OS), aix)
+  LIBEXT = a
+  SOFLAGS = -shared -static-libgcc
+  PICFLAGS += -pthread
+endif
+
+ifneq ($(findstring bsd, $(OS)),)
+  SOFLAGS = -shared -static-libgcc
+  CFLAGS += -pthread
+  LDFLAGS += -pthread
+endif
+
+ifeq ($(CPU), i386)
+  MODEL = 32
+endif
+
+ifeq ($(CPU), sparcv9)
+  MODEL = 64
+endif
+
+ifeq ($(CPU), amd64)
+  MODEL = 64
+endif
+
+ifeq ($(CPU), x86_64)
+  MODEL = 64
+endif
+
+ifeq ($(CPU), ppc64)
+  MODEL = 64
+endif
+
+ifeq ($(CPU), powerpc64)
+  MODEL = 64
+endif
+
+MODELFLAG =
+ifneq ($(MODEL),)
+  MODELFLAG = -m$(MODEL)
+endif
+
+# On platforms (linux, solaris) that support both 32bit and 64bit, force building for one or the other
+ifneq ($(or $(findstring linux, $(OS)), $(findstring solaris, $(OS))),)
+  # Change the CC/LD instead of CFLAGS/LDFLAGS, incase other things in the flags
+  # makes the libffi build choke
+  CC += $(MODELFLAG)
+  LD += $(MODELFLAG)
+endif
+
+LIBTEST = $(BUILD_DIR)/$(LIBNAME)
+
+all:	$(LIBTEST)
+
+$(TEST_BUILD_DIR)/%.o : $(SRC_DIR)/%.c
+	@mkdir -p $(@D)
+	$(CCACHE) $(CC) $(CFLAGS) -c $< -o $@
+
+$(LIBTEST):  $(TEST_OBJS)
+	$(CC) -o $@ $(LDFLAGS) $(TEST_OBJS) -lm
+
+clean::
+	# nothing to do - ant will delete the build dir
+
+debug::
+	@echo "SRCS=$(TEST_SRCS)"

data/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/GlobalVariable.c

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#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/.bundle/gems/ruby/2.2.0/gems/ffi-1.9.10/libtest/LastErrorTest.c

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+#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;
+}
+