yakg 0.0.4 → 0.0.6

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/lib/ffi/types.rb

@@ -0,0 +1,177 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+# All rights reserved.
+#
+# This file is part of ruby-ffi.
+#
+# This code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# see {file:README}
+module FFI
+
+  # @param [Type, DataConverter, Symbol] old type definition used by {FFI.find_type}
+  # @param [Symbol] add new type definition's name to add
+  # @return [Type]
+  # Add a definition type to type definitions.
+  def self.typedef(old, add)
+    TypeDefs[add] = self.find_type(old)
+  end
+
+  # (see FFI.typedef)
+  def self.add_typedef(old, add)
+    typedef old, add
+  end
+
+
+  # @param [Type, DataConverter, Symbol] name
+  # @param [Hash] type_map if nil, {FFI::TypeDefs} is used
+  # @return [Type]
+  # Find a type in +type_map+ ({FFI::TypeDefs}, by default) from
+  # a type objet, a type name (symbol). If +name+ is a {DataConverter},
+  # a new {Type::Mapped} is created.
+  def self.find_type(name, type_map = nil)
+    if name.is_a?(Type)
+      name
+
+    elsif type_map && type_map.has_key?(name)
+      type_map[name]
+
+    elsif TypeDefs.has_key?(name)
+      TypeDefs[name]
+
+    elsif name.is_a?(DataConverter)
+      (type_map || TypeDefs)[name] = Type::Mapped.new(name)
+    
+    else
+      raise TypeError, "unable to resolve type '#{name}'"
+    end
+  end
+
+  # List of type definitions
+  TypeDefs.merge!({
+      # The C void type; only useful for function return types
+      :void => Type::VOID,
+
+      # C boolean type
+      :bool => Type::BOOL,
+
+      # C nul-terminated string
+      :string => Type::STRING,
+
+      # C signed char
+      :char => Type::CHAR,
+      # C unsigned char
+      :uchar => Type::UCHAR,
+
+      # C signed short
+      :short => Type::SHORT,
+      # C unsigned short
+      :ushort => Type::USHORT,
+
+      # C signed int
+      :int => Type::INT,
+      # C unsigned int
+      :uint => Type::UINT,
+
+      # C signed long
+      :long => Type::LONG,
+
+      # C unsigned long
+      :ulong => Type::ULONG,
+
+      # C signed long long integer
+      :long_long => Type::LONG_LONG,
+
+      # C unsigned long long integer
+      :ulong_long => Type::ULONG_LONG,
+
+      # C single precision float
+      :float => Type::FLOAT,
+
+      # C double precision float
+      :double => Type::DOUBLE,
+
+      # C long double
+      :long_double => Type::LONGDOUBLE,
+
+      # Native memory address
+      :pointer => Type::POINTER,
+
+      # 8 bit signed integer
+      :int8 => Type::INT8,
+      # 8 bit unsigned integer
+      :uint8 => Type::UINT8,
+
+      # 16 bit signed integer
+      :int16 => Type::INT16,
+      # 16 bit unsigned integer
+      :uint16 => Type::UINT16,
+
+      # 32 bit signed integer
+      :int32 => Type::INT32,
+      # 32 bit unsigned integer
+      :uint32 => Type::UINT32,
+
+      # 64 bit signed integer
+      :int64 => Type::INT64,
+      # 64 bit unsigned integer
+      :uint64 => Type::UINT64,
+
+      :buffer_in => Type::BUFFER_IN,
+      :buffer_out => Type::BUFFER_OUT,
+      :buffer_inout => Type::BUFFER_INOUT,
+
+      # Used in function prototypes to indicate the arguments are variadic
+      :varargs => Type::VARARGS,
+  })
+
+  
+  class StrPtrConverter
+    extend DataConverter
+    native_type Type::POINTER
+
+    # @param [Pointer] val
+    # @param [] ctx
+    # @return [Array(String, Pointer)]
+    # Returns a [ String, Pointer ] tuple so the C memory for the string can be freed
+    def self.from_native(val, ctx)
+      [ val.null? ? nil : val.get_string(0), val ]
+    end
+
+  end
+
+  typedef(StrPtrConverter, :strptr)
+
+  # @param type +type+ is an instance of class accepted by {FFI.find_type}
+  # @return [Numeric]
+  # Get +type+ size, in bytes.
+  def self.type_size(type)
+    find_type(type).size
+  end
+
+  # Load all the platform dependent types
+  begin
+    File.open(File.join(Platform::CONF_DIR, 'types.conf'), "r") do |f|
+      prefix = "rbx.platform.typedef."
+      f.each_line { |line|
+        if line.index(prefix) == 0
+          new_type, orig_type = line.chomp.slice(prefix.length..-1).split(/\s*=\s*/)
+          typedef(orig_type.to_sym, new_type.to_sym)
+        end
+      }
+    end
+    typedef :pointer, :caddr_t
+  rescue Errno::ENOENT
+  end
+end

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/lib/ffi/union.rb

@@ -0,0 +1,32 @@
+#
+# Copyright (C) 2008-2010 Wayne Meissner
+#
+# All rights reserved.
+#
+# This file is part of ruby-ffi.
+#
+# This code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ffi/struct'
+
+module FFI
+
+  class Union < FFI::Struct
+    def self.builder
+      b = StructLayoutBuilder.new
+      b.union = true
+      b
+    end
+  end
+end

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/lib/ffi/variadic.rb

@@ -0,0 +1,65 @@
+#
+# Copyright (C) 2008, 2009 Wayne Meissner
+# Copyright (C) 2009 Luc Heinrich
+# All rights reserved.
+#
+# This file is part of ruby-ffi.
+#
+# This code is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License version 3 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+# version 3 for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
+
+module FFI
+  class VariadicInvoker    
+    def init(arg_types, type_map)
+      @fixed = Array.new
+      @type_map = type_map
+      arg_types.each_with_index do |type, i|
+        @fixed << type unless type == Type::VARARGS
+      end
+    end
+
+
+    def call(*args, &block)
+      param_types = Array.new(@fixed)
+      param_values = Array.new
+      @fixed.each_with_index do |t, i|
+        param_values << args[i]
+      end
+      i = @fixed.length
+      while i < args.length
+        param_types << FFI.find_type(args[i], @type_map)
+        param_values << args[i + 1]
+        i += 2
+      end
+      invoke(param_types, param_values, &block)
+    end
+
+    #
+    # Attach the invoker to module +mod+ as +mname+
+    #
+    def attach(mod, mname)
+      invoker = self
+      params = "*args"
+      call = "call"
+      mod.module_eval <<-code
+      @@#{mname} = invoker
+      def self.#{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      def #{mname}(#{params})
+        @@#{mname}.#{call}(#{params})
+      end
+      code
+      invoker
+    end
+  end
+end

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/lib/ffi/version.rb

@@ -0,0 +1,4 @@
+module FFI
+  VERSION = '1.8.1'
+end
+

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/lib/ffi.rb

@@ -0,0 +1,28 @@
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'rbx'
+  Object.send(:remove_const, :FFI) if defined?(::FFI)
+  begin
+    if RUBY_VERSION =~ /1.8/
+      require '1.8/ffi_c'
+    elsif RUBY_VERSION =~ /1.9/
+      require '1.9/ffi_c'
+    elsif RUBY_VERSION =~ /2.0/
+      require '2.0/ffi_c'
+    else
+      require 'ffi_c'
+    end
+  rescue Exception
+    require 'ffi_c'
+  end
+
+  require 'ffi/ffi'
+
+elsif defined?(RUBY_ENGINE)
+  # Remove the ffi gem dir from the load path, then reload the internal ffi implementation
+  $LOAD_PATH.delete(File.dirname(__FILE__))
+  $LOAD_PATH.delete(File.join(File.dirname(__FILE__), 'ffi'))
+  unless $LOADED_FEATURES.nil?
+    $LOADED_FEATURES.delete(__FILE__)
+    $LOADED_FEATURES.delete('ffi.rb')
+  end
+  require 'ffi.rb'
+end

data/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/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/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/libtest/BoolTest.c

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. 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/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/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/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/libtest/ClosureTest.c

@@ -0,0 +1,190 @@
+/*
+ * 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);
+
+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/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/libtest/EnumTest.c

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2007 Wayne Meissner. All rights reserved.
+ *
+ * For licensing, see LICENSE.SPECS
+ */
+
+int test_untagged_enum(int val) {
+    return val;
+}
+
+int test_untagged_typedef_enum(int 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/vendor/gems/ruby/1.9.1/gems/ffi-1.8.1/libtest/FunctionTest.c

@@ -0,0 +1,58 @@
+/*
+ * 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
+}